DayZOfficialSourceCode/Scripts/5_mission/gui/inventorynew/containeditems/icon.c

class Icon: LayoutHolder
{
	protected int					m_SizeX;
	protected int					m_SizeY;
	protected int					m_PosX;
	protected int					m_PosY;
	
	protected EntityAI				m_Lock;
	protected bool					m_IsWeapon			= false;
	protected bool					m_IsMagazine		= false;
	protected bool					m_HasTemperature	= false;
	protected bool					m_HasQuantity		= false;
	protected float					m_CurrQuantity		= -1;
	
	protected EntityAI				m_Obj;
	protected ItemBase				m_Item;
	protected bool					m_HandsIcon;
	protected int					m_CargoPos;
	protected bool					m_IsDragged;
	protected bool					m_PreviousFlipOrientation;
	
	const int NUMBER_OF_TIMERS = 2;
	
	protected ItemPreviewWidget		m_ItemPreview;
	
	protected Widget				m_ColorWidget;
	protected Widget				m_SelectedPanel;
	protected Widget				m_MicromanagedPanel;
	protected Widget				m_CursorWidget;
	
	protected Widget				m_QuantityPanel;
	protected TextWidget			m_QuantityItem;
	protected ProgressBarWidget		m_QuantityProgress;
	protected Widget				m_QuantityStack;
	
	protected Widget				m_ItemSizePanel;
	protected TextWidget			m_ItemSizeWidget;
	
	protected ref array<ImageWidget>	m_AmmoIcons;
	protected ImageWidget				m_AmmoTypeIcon;

	void Icon( LayoutHolder parent, bool hands_icon = false )
	{
		m_HandsIcon = hands_icon;
		ItemManager.GetInstance().SetSelectedItemEx(null, null, null);
		
		m_ItemPreview		= ItemPreviewWidget.Cast( GetMainWidget().FindAnyWidget( "Render" ));
		
		m_ColorWidget		= GetMainWidget().FindAnyWidget( "Color" );
		m_SelectedPanel		= GetMainWidget().FindAnyWidget( "Selected" );
		m_MicromanagedPanel	= GetMainWidget().FindAnyWidget( "Micromanaged" );
		m_CursorWidget		= GetMainWidget().FindAnyWidget( "Cursor" );
		
		m_QuantityPanel		= GetMainWidget().FindAnyWidget( "QuantityPanel" );
		m_QuantityItem		= TextWidget.Cast( GetMainWidget().FindAnyWidget( "Quantity" ) );
		m_QuantityProgress	= ProgressBarWidget.Cast( GetMainWidget().FindAnyWidget( "QuantityBar" ) );
		m_QuantityStack		= GetMainWidget().FindAnyWidget( "QuantityStackPanel" );
		
		m_ItemSizePanel		= GetMainWidget().FindAnyWidget( "ItemSizePanel" );
		m_ItemSizeWidget	= TextWidget.Cast( GetMainWidget().FindAnyWidget( "ItemSize" ) );
		
		m_AmmoTypeIcon		= ImageWidget.Cast( GetMainWidget().FindAnyWidget( "AmmoTypeIcon" ) );
		SetActive( false );
	}
	
	void ~Icon()
	{
		if (m_Obj)
		{
			m_Obj.GetOnItemFlipped().Remove(UpdateFlip);
			m_Obj.GetOnViewIndexChanged().Remove(SetItemPreview);
		}
		
		if (m_IsDragged)
		{
			RevertToOriginalFlip();
			ItemManager.GetInstance().HideDropzones();
			ItemManager.GetInstance().SetIsDragging(false);
			m_IsDragged = false;
		}
	}
	
	Widget GetSelectedWidget()
	{
		return m_SelectedPanel;
	}
	
	Widget GetCursorWidget()
	{
		return m_CursorWidget;
	}
	
	Widget GetMicromanagedPanel()
	{
		return m_MicromanagedPanel;
	}

	bool IsDragged()
	{
		return m_IsDragged;
	}

	override void SetActive( bool active )
	{
		super.SetActive(active);
		if (active && GetObject())
		{
			float x, y;
			GetMainWidget().GetScreenPos(x, y);
			PrepareOwnedTooltip(EntityAI.Cast( GetObject() ), -1, y);
		}
		else
		{
			HideOwnedTooltip();
		}
		
		m_SelectedPanel.Show(active);
	}
	
	override void SetParentWidget()
	{
		#ifndef PLATFORM_CONSOLE
		if (m_Parent.IsInherited(HandsPreview))
		{ 
			super.SetParentWidget();
		}
		else
		{
			if (m_Parent != null)
			{
				CargoContainer gridContainer = CargoContainer.Cast(m_Parent);
				if (gridContainer)
				{
					m_ParentWidget = gridContainer.GetMainWidget();
				}
			}
		}
		#else
		super.SetParentWidget();
		#endif
	}
	
	int GetRelevantInventoryAction(int relevantActions)
	{
		return 0;
	
	}

	void RefreshQuickbar()
	{
		InventoryMenu menu = InventoryMenu.Cast(GetGame().GetUIManager().FindMenu(MENU_INVENTORY));
		HideOwnedTooltip();
		if (menu)
		{
			menu.RefreshQuickbar();
		}
	}

	void DoubleClick(Widget w, int x, int y, int button)
	{
		if (button == MouseState.LEFT && !g_Game.IsLeftCtrlDown())
		{
			PlayerBase controlledPlayer = PlayerBase.Cast(GetGame().GetPlayer());
			if (controlledPlayer.GetInventory().HasInventoryReservation(m_Obj, null) || controlledPlayer.GetInventory().IsInventoryLocked() || controlledPlayer.IsItemsToDelete())
				return;
			
			ItemPreviewWidget targetIpw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
			if (!targetIpw)
			{
				string name = w.GetName();
				name.Replace("PanelWidget", "Render");
				targetIpw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
			}
			
			if (!targetIpw)
				targetIpw = ItemPreviewWidget.Cast(w);
	
			EntityAI targetEntity = targetIpw.GetItem();
			if (targetIpw)
			{
				if (!targetEntity.GetInventory().CanRemoveEntity())
					return;
				
				if (m_HandsIcon)
				{
					if (controlledPlayer.GetHumanInventory().CanRemoveEntityInHands())
						controlledPlayer.PredictiveMoveItemFromHandsToInventory();
	
					RefreshQuickbar();
	
					return;
				}
		
				EntityAI entityInHands = controlledPlayer.GetHumanInventory().GetEntityInHands();
				EntityAI entityRootParent = targetEntity.GetHierarchyRoot();
				
				if (controlledPlayer.GetInventory().HasEntityInInventory(targetEntity) && controlledPlayer.GetHumanInventory().CanAddEntityInHands(targetEntity))
				{
					controlledPlayer.PredictiveTakeEntityToHands(targetEntity);
				}
				else if (entityInHands && entityRootParent == controlledPlayer)
				{
					InventoryLocation targetItemLocation = new InventoryLocation();
					InventoryLocation handsItemLocation = new InventoryLocation();
					entityInHands.GetInventory().GetCurrentInventoryLocation(handsItemLocation);
					int index = controlledPlayer.GetHumanInventory().FindUserReservedLocationIndex(entityInHands);
					if (index >= 0)
						controlledPlayer.GetHumanInventory().GetUserReservedLocation(index, targetItemLocation);
					
					if (controlledPlayer.GetInventory().CanForceSwapEntitiesEx(targetEntity, targetItemLocation, entityInHands, handsItemLocation))
					{
						controlledPlayer.PredictiveForceSwapEntities(targetEntity, entityInHands, targetItemLocation);
					}
					else if (controlledPlayer.GetInventory().CanSwapEntitiesEx(targetEntity, entityInHands ))
					{
						controlledPlayer.PredictiveSwapEntities(targetEntity, entityInHands);
					}
					else
					{
						controlledPlayer.GetInventory().FindFreeLocationFor(targetEntity, FindInventoryLocationType.ANY, targetItemLocation);
						if (targetItemLocation.IsValid() && controlledPlayer.GetInventory().LocationCanAddEntity(targetItemLocation))
							SplitItemUtils.TakeOrSplitToInventoryLocation(controlledPlayer, targetItemLocation);
					}
				}
				else
				{
					bool found = false;
					if (targetEntity.GetInventory().CanRemoveEntity())
					{
						InventoryLocation i2 = new InventoryLocation();
						found = controlledPlayer.GetInventory().FindFreeLocationFor(targetEntity, FindInventoryLocationType.ANY, i2);
						if (found)
						{
							if (i2.GetType() == FindInventoryLocationType.ATTACHMENT)
							{
								if (i2.GetParent() != controlledPlayer)
									found = false;
							}
						}
					}
	
					if (found)
					{
						if (controlledPlayer.GetHumanInventory().CanAddEntityToInventory(targetEntity))
							controlledPlayer.PredictiveTakeEntityToInventory(FindInventoryLocationType.ANY, targetEntity);
					}
					else
					{
						if (controlledPlayer.GetHumanInventory().CanAddEntityInHands(targetEntity))
							controlledPlayer.PredictiveTakeEntityToHands(targetEntity);
					}
				}
				
				RefreshQuickbar();
			}
		}
	}

	void DraggingOverSwap( Widget w, int x, int y, Widget receiver )
	{
		if (w == null)
		{
			return;
		}
		
		string name = w.GetName();
		name.Replace("PanelWidget", "Render");

		ItemPreviewWidget targetIpw = ItemPreviewWidget.Cast(receiver.FindAnyWidget( "Render" ));
		if (m_HandsIcon)
		{
			targetIpw = ItemPreviewWidget.Cast(receiver.GetParent().FindAnyWidget( "Render" ));
		}

		ItemPreviewWidget selectedIpw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
		if (selectedIpw == null)
		{
			selectedIpw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
		}
		
		if (selectedIpw == null)
		{
			return;
		}

		InventoryItem targetEntity = InventoryItem.Cast(targetIpw.GetItem());
		InventoryItem selectedEntity = InventoryItem.Cast(selectedIpw.GetItem());
		if (!selectedEntity || !targetEntity)
		{
			return;
		}
		
		InventoryLocation il = new InventoryLocation();
		PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
		int index = player.GetHumanInventory().FindUserReservedLocationIndex(m_Item);
		
		if (index >= 0)
		{	
			player.GetHumanInventory().GetUserReservedLocation(index, il);
			
			if (GameInventory.CanForceSwapEntitiesEx(selectedEntity, null, targetEntity, il))
			{
				ColorManager.GetInstance().SetColor(w, ColorManager.FSWAP_COLOR);
				ItemManager.GetInstance().HideDropzones();
				ItemManager.GetInstance().ShowSourceDropzone(il.GetParent());
				return;
			}
		}
		static int testedFlags = InventoryCombinationFlags.SWAP | InventoryCombinationFlags.FSWAP;
		
		int chosenInventoryAction = ItemManager.GetChosenCombinationFlag(selectedEntity, targetEntity, testedFlags, il);
		UpdateFrameColor(selectedEntity, targetEntity, chosenInventoryAction, w, il);
	}

	void DraggingOverCombine(Widget w, int x, int y, Widget receiver)
	{
		if (w == null)
		{
			return;
		}
		
		ItemPreviewWidget selectedIpw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
		if (!selectedIpw)
		{
			string name = w.GetName();
			name.Replace("PanelWidget", "Render");
			selectedIpw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
		}
		
		if (!selectedIpw)
		{
			selectedIpw = ItemPreviewWidget.Cast(w);
		}
		
		if (!selectedIpw.GetItem())
		{
			return;
		}
		EntityAI selectedEntity = selectedIpw.GetItem();
		EntityAI targetEntity = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();

		static int testedFlags = InventoryCombinationFlags.SET_ACTION | InventoryCombinationFlags.PERFORM_ACTION | InventoryCombinationFlags.COMBINE_QUANTITY2 | InventoryCombinationFlags.ADD_AS_CARGO | InventoryCombinationFlags.ADD_AS_ATTACHMENT;
		
		int chosenInventoryAction = ItemManager.GetChosenCombinationFlag(selectedEntity, targetEntity, testedFlags);
		UpdateFrameColor(selectedEntity, targetEntity, chosenInventoryAction, w);
	}

	bool MouseEnter(Widget w, int x, int y)
	{
		if (!m_IsDragged)
		{
			PrepareOwnedTooltip(m_Obj, x, y);
			m_CursorWidget.Show(true);
		}
		
		return true;
	}

	bool MouseLeave( Widget w, Widget s, int x, int y)
	{
		HideOwnedTooltip();
		if (!m_IsDragged)
		{
			m_CursorWidget.Show(false);
		}
		return true;
	}

	void DraggingOver( Widget w, int x, int y, Widget receiver )
	{
		ItemManager.GetInstance().HideDropzones();
		
		if (w == null)
		{
			return;
		}
		string name = w.GetName();
		name.Replace("PanelWidget", "Render");

		ItemPreviewWidget targetIpw = ItemPreviewWidget.Cast(receiver.FindAnyWidget( "Render" ));
		if (m_HandsIcon)
		{
			targetIpw = ItemPreviewWidget.Cast(receiver.GetParent().FindAnyWidget( "Render" ));
		}

		ItemPreviewWidget selectedIpw = ItemPreviewWidget.Cast(w.FindAnyWidget( name ));
		if (selectedIpw == null)
		{
			selectedIpw = ItemPreviewWidget.Cast(w.FindAnyWidget( "Render" ));
		}
		if (selectedIpw == null)
		{
			return;
		}

		PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
		InventoryItem targetEntity = InventoryItem.Cast(targetIpw.GetItem());
		InventoryItem selectedEntity = InventoryItem.Cast(selectedIpw.GetItem());
		InventoryLocation ilDst;
		if (!targetEntity || !selectedEntity)
		{
			return;
		}
		
		if (m_Lock)
		{
			if (targetEntity == selectedEntity)
			{
				ColorManager.GetInstance().SetColor( w, ColorManager.SWAP_COLOR );
				ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
			}
			else
			{
				CargoContainer parentContainer = CargoContainer.Cast(m_Parent);
			
				float parentX;
				float parentY;
			
				parentContainer.GetRootWidget().GetScreenPos(parentX, parentY);
			
				float iconSize = parentContainer.GetIconSize();
				float spaceSize = parentContainer.GetSpaceSize();
			
				int PosX = (x - parentX) / (iconSize + spaceSize);
				int PosY = (y - parentY) / (iconSize + spaceSize);
			
				EntityAI parent = m_Lock;
				CargoBase targetCargo 	= parent.GetInventory().GetCargo();
			
				ilDst = new InventoryLocation();			
				ilDst.SetCargoAuto(targetCargo, selectedEntity, PosY, PosX, selectedEntity.GetInventory().GetFlipCargo());
		
				if (parent.GetInventory().LocationCanAddEntity(ilDst))
				{
					ColorManager.GetInstance().SetColor(w, ColorManager.GREEN_COLOR);
					ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
				}
				else
				{
					ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
					ItemManager.GetInstance().ShowSourceDropzone(selectedEntity);
				}
			}
		}
		else 
		{
			static int testedFlags = InventoryCombinationFlags.COMBINE_QUANTITY2 | InventoryCombinationFlags.ADD_AS_CARGO | InventoryCombinationFlags.ADD_AS_ATTACHMENT | InventoryCombinationFlags.SWAP | InventoryCombinationFlags.FSWAP | InventoryCombinationFlags.SWAP_MAGAZINE;
		
			int chosenInventoryAction = ItemManager.GetChosenCombinationFlag(selectedEntity, targetEntity, testedFlags, ilDst);
			UpdateFrameColor(selectedEntity, targetEntity, chosenInventoryAction, w, ilDst);
		}
	}

	void OnPerformCombination( int combinationFlags )
	{
		PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
		if (m_am_entity1 == null || m_am_entity2 == null) return;

		if (combinationFlags == InventoryCombinationFlags.NONE) return;

		Weapon_Base wpn;
		Magazine mag;

		if (combinationFlags & InventoryCombinationFlags.PERFORM_ACTION)
		{
			ActionManagerClient amc;
			Class.CastTo(amc, player.GetActionManager());

			if (m_am_entity1 == player.GetHumanInventory().GetEntityInHands())
			{
				amc.PerformActionFromInventory(ItemBase.Cast( m_am_entity1 ),ItemBase.Cast( m_am_entity2 ));
			}
			else
			{
				amc.PerformActionFromInventory(ItemBase.Cast( m_am_entity2 ),ItemBase.Cast( m_am_entity1 ));
			}
		}
		else if (combinationFlags & InventoryCombinationFlags.SET_ACTION)
		{
			ActionManagerClient amc2;
			Class.CastTo(amc2, player.GetActionManager());

			if (m_am_entity1 == player.GetHumanInventory().GetEntityInHands())
			{
				amc2.SetActionFromInventory(ItemBase.Cast( m_am_entity1 ), ItemBase.Cast( m_am_entity2 ));
			}
			else
			{
				amc2.SetActionFromInventory(ItemBase.Cast( m_am_entity2 ), ItemBase.Cast( m_am_entity1 ));
			}
		}
		else if (combinationFlags & InventoryCombinationFlags.COMBINE_QUANTITY2)
		{
			ItemBase entity = ItemBase.Cast(m_am_entity1);
			entity.CombineItemsClient(ItemBase.Cast( m_am_entity2 ));
		}
		else if (combinationFlags & InventoryCombinationFlags.ADD_AS_ATTACHMENT)
		{
			float stackable = m_am_entity2.GetTargetQuantityMax(-1);
		
			if (stackable == 0 || stackable >= m_am_entity2.GetQuantity())
			{
				player.PredictiveTakeEntityToTargetAttachment(m_am_entity1, m_am_entity2);
			}
			else
			{
				InventoryLocation il = new InventoryLocation();
				m_am_entity1.GetInventory().FindFreeLocationFor(m_am_entity2, FindInventoryLocationType.ATTACHMENT, il);
				ItemBase.Cast(m_am_entity2).SplitIntoStackMaxToInventoryLocationClient(il);
			}
		}
		else if (combinationFlags & InventoryCombinationFlags.ADD_AS_CARGO)
		{
			SplitItemUtils.TakeOrSplitToInventory(player, m_am_entity1, m_am_entity2);
		}
	}
	
	bool PerformCombination(EntityAI selectedEntity, EntityAI targetEntity, int combinationFlag, InventoryLocation ilSwapDst = null)
	{
		PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
		ActionManagerClient amc;
		
		switch (combinationFlag)
		{
			case InventoryCombinationFlags.ADD_AS_ATTACHMENT:
				return player.PredictiveTakeEntityToTargetAttachment(targetEntity, selectedEntity);
			case InventoryCombinationFlags.ADD_AS_CARGO:
				SplitItemUtils.TakeOrSplitToInventory(player, targetEntity, selectedEntity);
				return true;
			case InventoryCombinationFlags.COMBINE_QUANTITY2:
				targetEntity.CombineItemsClient(selectedEntity);
				return true;
			case InventoryCombinationFlags.SET_ACTION:
				Class.CastTo(amc, player.GetActionManager());
				if (targetEntity == player.GetHumanInventory().GetEntityInHands())
				{
					amc.SetActionFromInventory(ItemBase.Cast(targetEntity), ItemBase.Cast(selectedEntity));
				}
				else
				{
					amc.SetActionFromInventory(ItemBase.Cast(selectedEntity), ItemBase.Cast(targetEntity));
				}
				return true;
			case InventoryCombinationFlags.PERFORM_ACTION:
				Class.CastTo(amc, player.GetActionManager());
				if (targetEntity == player.GetHumanInventory().GetEntityInHands())
				{
					amc.PerformActionFromInventory(ItemBase.Cast(targetEntity), ItemBase.Cast(selectedEntity));
				}
				else
				{
					amc.PerformActionFromInventory(ItemBase.Cast(selectedEntity), ItemBase.Cast(targetEntity));
				}
				return true;
			case InventoryCombinationFlags.SWAP_MAGAZINE:
				return player.GetWeaponManager().SwapMagazine(Magazine.Cast(selectedEntity));
			case InventoryCombinationFlags.SWAP:
				return player.PredictiveSwapEntities(targetEntity, selectedEntity);
			case InventoryCombinationFlags.FSWAP:
				return player.PredictiveForceSwapEntities(selectedEntity, targetEntity, ilSwapDst);
			default:
				return false;
		}

		return false;
	}

	void UpdateFrameColor(EntityAI selectedEntity, EntityAI targetEntity, int combinationFlag, Widget w, InventoryLocation il = null)
	{
		int color;
		Widget targetDropzone;
		
		ItemManager.GetInstance().HideDropzones();
		switch (combinationFlag)
		{
			case InventoryCombinationFlags.ADD_AS_ATTACHMENT:
			case InventoryCombinationFlags.ADD_AS_CARGO:
				color = ColorManager.GREEN_COLOR;
				ItemManager.GetInstance().ShowSourceDropzone(targetEntity);
				break;
			case InventoryCombinationFlags.COMBINE_QUANTITY2:
			case InventoryCombinationFlags.SET_ACTION:
			case InventoryCombinationFlags.PERFORM_ACTION:
				color = ColorManager.COMBINE_COLOR;
				ItemManager.GetInstance().ShowSourceDropzone(targetEntity);
				break;
			case InventoryCombinationFlags.SWAP_MAGAZINE:
				color = ColorManager.SWAP_COLOR;
				ItemManager.GetInstance().ShowSourceDropzone(selectedEntity);
				break;
			case InventoryCombinationFlags.SWAP:
				color = ColorManager.SWAP_COLOR;
				ItemManager.GetInstance().ShowSourceDropzone(selectedEntity);
				break;
			case InventoryCombinationFlags.FSWAP:
				color = ColorManager.FSWAP_COLOR;
				if (il)
				{
					ItemManager.GetInstance().ShowSourceDropzone(il.GetParent());
				}
				else
				{
					ItemManager.GetInstance().ShowSourceDropzone(selectedEntity);
				}
				break;
			default:
				color = ColorManager.RED_COLOR;
				ItemManager.GetInstance().ShowSourceDropzone(selectedEntity);
		}

		ColorManager.GetInstance().SetColor( w, color );
	}

	

	void ShowActionMenuCombine( EntityAI entity1, EntityAI entity2, int combinationFlags, Widget w , bool color_test )
	{
		int lastFlag = 0;
		ContextMenu cmenu = ContextMenu.Cast(GetGame().GetUIManager().GetMenu().GetContextMenu());
		m_am_entity1 = entity1;
		m_am_entity2 = entity2;
		cmenu.Hide();
		cmenu.Clear();
		int id = -1;

		if ( entity1 == null || entity2 == null ) return;

		if ( combinationFlags == InventoryCombinationFlags.NONE )
		{
			if ( color_test )
			{
				ColorManager.GetInstance().SetColor( w, ColorManager.RED_COLOR );
				ItemManager.GetInstance().ShowSourceDropzone( entity2 );
			}
			return;
		}

		if (combinationFlags & InventoryCombinationFlags.ADD_AS_CARGO)
		{
			lastFlag = InventoryCombinationFlags.ADD_AS_CARGO;
			cmenu.Add( "#inv_context_add_as_cargo", this, "OnPerformCombination", new Param1<int>( lastFlag ) );
		}
		if (combinationFlags & InventoryCombinationFlags.ADD_AS_ATTACHMENT)
		{
			lastFlag = InventoryCombinationFlags.ADD_AS_ATTACHMENT;
			cmenu.Add( "#inv_context_add_as_attachment", this, "OnPerformCombination", new Param1<int>( lastFlag ));
		}
		
		if (combinationFlags & InventoryCombinationFlags.COMBINE_QUANTITY2)
		{
			lastFlag = InventoryCombinationFlags.COMBINE_QUANTITY2;
			cmenu.Add("#inv_context_combine_quantity", this, "OnPerformCombination", new Param1<int>( lastFlag ));
		}

		if (combinationFlags & InventoryCombinationFlags.SET_ACTION)
		{
			lastFlag = InventoryCombinationFlags.SET_ACTION;
			cmenu.Add("#inv_context_attach_magazine", this, "OnPerformCombination", new Param1<int>( lastFlag ));
		}
		
		if (combinationFlags & InventoryCombinationFlags.PERFORM_ACTION)
		{
			lastFlag = InventoryCombinationFlags.PERFORM_ACTION;
			cmenu.Add("Perform action", this, "OnPerformCombination", new Param1<int>( lastFlag ));
		}

		if (color_test)
		{
			if (lastFlag == 0)
			{
				ItemManager.GetInstance().HideDropzones();
				ItemManager.GetInstance().GetCenterDropzone().SetAlpha( 1 );
				ColorManager.GetInstance().SetColor( w, ColorManager.RED_COLOR );
			}
			else if (lastFlag == InventoryCombinationFlags.ADD_AS_ATTACHMENT || lastFlag == InventoryCombinationFlags.ADD_AS_CARGO )
			{
				ItemManager.GetInstance().HideDropzones();
				ItemManager.GetInstance().GetCenterDropzone().SetAlpha( 1 );
				ColorManager.GetInstance().SetColor( w, ColorManager.GREEN_COLOR );
			}
			else
			{
				ItemManager.GetInstance().HideDropzones();
				ItemManager.GetInstance().GetCenterDropzone().SetAlpha( 1 );
				ColorManager.GetInstance().SetColor( w, ColorManager.COMBINE_COLOR );
			}
		}
		else if (cmenu.Count() >= 1)
		{
			OnPerformCombination(combinationFlags);
			return;
		}	
	}

	void OnPerformRecipe(int id)
	{
		if ( m_am_entity1 == null || m_am_entity2 == null ) return;

		Debug.Log("OnPerformRecipe called for id:"+id.ToString(),"recipes");
		PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
		player.GetCraftingManager().SetInventoryCraft( id, ItemBase.Cast(m_am_entity1), ItemBase.Cast(m_am_entity2));
	}

	void Combine( Widget w, int x, int y, Widget receiver )
	{
		ItemManager.GetInstance().HideDropzones();
		ItemManager.GetInstance().SetIsDragging(false);
		ItemPreviewWidget selectedIpw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
		if (!selectedIpw)
		{
			string name = w.GetName();
			name.Replace("PanelWidget", "Render");
			selectedIpw = ItemPreviewWidget.Cast(w.FindAnyWidget( name ));
		}
		if (!selectedIpw)
		{
			selectedIpw = ItemPreviewWidget.Cast(w);
		}
		if (!selectedIpw.GetItem())
		{
			return;
		}
		EntityAI selectedEntity = selectedIpw.GetItem();
		EntityAI targetEntity = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
		static int testedFlags = InventoryCombinationFlags.SET_ACTION | InventoryCombinationFlags.PERFORM_ACTION | InventoryCombinationFlags.COMBINE_QUANTITY2 | InventoryCombinationFlags.ADD_AS_CARGO | InventoryCombinationFlags.ADD_AS_ATTACHMENT;
		
		int chosenInventoryAction = ItemManager.GetChosenCombinationFlag(selectedEntity, targetEntity, testedFlags);
		PerformCombination(selectedEntity, targetEntity, chosenInventoryAction);
	}
	
	bool CombineItems( EntityAI entity1, EntityAI entity2 )
	{
		int flags = ItemManager.GetCombinationFlags( entity1, entity2 );
		return FlagAction( entity1, entity2, flags );
	}
	
	bool FlagAction( EntityAI entity1, EntityAI entity2, int combinationFlags )
	{
		int current_flag;
		ContextMenu cmenu = ContextMenu.Cast(GetGame().GetUIManager().GetMenu().GetContextMenu());
		m_am_entity1 = entity1;
		m_am_entity2 = entity2;
		cmenu.Hide();
		cmenu.Clear();
		int id = -1;

		if (combinationFlags & InventoryCombinationFlags.COMBINE_QUANTITY2 )
		{
			ItemBase entity = ItemBase.Cast( entity1 );
			entity.CombineItemsClient( ItemBase.Cast( entity2 ) );
			return false;
		}

		if (entity1 == null || entity2 == null || combinationFlags == InventoryCombinationFlags.NONE )
			return true;

		if (combinationFlags & InventoryCombinationFlags.ADD_AS_ATTACHMENT )
		{
			current_flag = InventoryCombinationFlags.ADD_AS_ATTACHMENT;
			cmenu.Add( "#inv_context_add_as_attachment", this, "OnPerformCombination", new Param1<int>( current_flag ) );
		}
		/*if (combinationFlags & InventoryCombinationFlags.LOAD_CHAMBER )
		{
			current_flag = InventoryCombinationFlags.LOAD_CHAMBER;
			cmenu.Add( "#inv_context_load_chamber", this, "OnPerformCombination", new Param1<int>( current_flag ) );
		}*/
		if(combinationFlags & InventoryCombinationFlags.ATTACH_MAGAZINE)
		{
			current_flag = InventoryCombinationFlags.ATTACH_MAGAZINE;
			cmenu.Add("#inv_context_attach_magazine", this, "OnPerformCombination", new Param1<int>( current_flag ) );
		}

		if (combinationFlags & InventoryCombinationFlags.ADD_AS_CARGO )
		{
			current_flag = InventoryCombinationFlags.ADD_AS_CARGO;
			cmenu.Add( "#inv_context_add_as_cargo", this, "OnPerformCombination", new Param1<int>( current_flag ) );
		}

		if (combinationFlags & InventoryCombinationFlags.SWAP )
		{
			current_flag = InventoryCombinationFlags.SWAP;
			cmenu.Add( "#inv_context_swap", this, "OnPerformCombination", new Param1<int>( current_flag ) );
		}

		if (combinationFlags & InventoryCombinationFlags.COMBINE_QUANTITY2 )
		{
			current_flag = InventoryCombinationFlags.COMBINE_QUANTITY2;
			cmenu.Add( "#inv_context_combine", this, "OnPerformCombination", new Param1<int>( current_flag ) );
		}

		if(combinationFlags & InventoryCombinationFlags.SET_ACTION)
		{
			current_flag = InventoryCombinationFlags.SET_ACTION;
			cmenu.Add("#inv_context_attach_magazine", this, "OnPerformCombination", new Param1<int>( current_flag ) );
		}
		
		if(combinationFlags & InventoryCombinationFlags.PERFORM_ACTION)
		{
			current_flag = InventoryCombinationFlags.PERFORM_ACTION;
			cmenu.Add("Perform Action2", this, "OnPerformCombination", new Param1<int>( current_flag ) );
		}

		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;

		MissionGameplay mission = MissionGameplay.Cast( GetGame().GetMission() );
		/*if (combinationFlags & InventoryCombinationFlags.RECIPE_HANDS ||  combinationFlags & InventoryCombinationFlags.RECIPE_ANYWHERE )
		{
			OnPerformRecipe( id );
			return true;
		}
		else /*if (cmenu.Count() == 1 )*/
		//{
			OnPerformCombination( current_flag );
			return true;
		//}
		/*else
		{
			cmenu.Show( m_am_Pos_x, m_am_Pos_y );
			return true;
		}*/
	}

	void MouseClick(Widget w, int x, int y, int button)
	{
		if (button == MouseState.RIGHT)
		{
			if (m_Lock)
			{
				GetGame().GetPlayer().GetHumanInventory().ClearUserReservedLocationSynced(m_Item);
			}
			else if (m_Item)
			{
				#ifdef DIAG_DEVELOPER
				if (GetDayZGame().IsLeftCtrlDown())
					ShowActionMenu(m_Item);
				else
				#endif
				{
					m_Item.OnRightClick();
					
					if (m_HasQuantity)
						SetQuantity();
				}
			}
				
		}
		else if (!m_Lock)
		{
			switch (button)
			{
				case MouseState.MIDDLE:
					InspectItem(m_Item);
					break;
				
				case MouseState.LEFT:
					PlayerBase controlledPlayer = PlayerBase.Cast(GetGame().GetPlayer());
					if (g_Game.IsLeftCtrlDown())
					{
						if (controlledPlayer.CanDropEntity(m_Item))
						{
							if (m_Item.GetTargetQuantityMax() < m_Item.GetQuantity())
								m_Item.SplitIntoStackMaxClient(null, -1);
							else
								controlledPlayer.PhysicalPredictiveDropItem(m_Item);
	
							ItemManager.GetInstance().SetWidgetDraggable(w, false);
						}
					}
					else
					{
						InventoryLocation il = new InventoryLocation();
						m_Obj.GetInventory().GetCurrentInventoryLocation(il);
		
						bool draggable = !controlledPlayer.GetInventory().HasInventoryReservation(m_Obj, null) && !controlledPlayer.GetInventory().IsInventoryLocked() && !controlledPlayer.IsItemsToDelete();
						draggable = draggable && (m_Obj.GetHierarchyRoot() && m_Obj.GetInventory().CanRemoveEntity() || !m_Obj.GetHierarchyRoot() && AttachmentsOutOfReach.IsAttachmentReachable(m_Obj, "", il.GetSlot()));
				
						ItemManager.GetInstance().SetWidgetDraggable(w, draggable);				
					}
					break;
			}
		}
	}

	void DropReceivedFromMain( Widget w, int x, int y, Widget receiver )
	{
		ItemManager.GetInstance().HideDropzones();
		ItemManager.GetInstance().SetIsDragging(false);
		string name = w.GetName();
		name.Replace("PanelWidget", "Render");
		PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
		
		ItemPreviewWidget targetIpw = ItemPreviewWidget.Cast(receiver.FindAnyWidget( "Render" ));
		if (m_HandsIcon)
		{
			targetIpw = ItemPreviewWidget.Cast(receiver.GetParent().FindAnyWidget( "Render" ));
		}

		ItemPreviewWidget selectedIpw = ItemPreviewWidget.Cast(w.FindAnyWidget( name ));
		if (selectedIpw == null)
		{
			selectedIpw = ItemPreviewWidget.Cast(w.FindAnyWidget( "Render" ));
		}
		if (selectedIpw == null)
		{
			return;
		}

		InventoryItem targetEntity = InventoryItem.Cast(targetIpw.GetItem());
		InventoryItem selectedEntity = InventoryItem.Cast(selectedIpw.GetItem());
		if (!selectedEntity)
		{
			return;
		}
		int index;
		InventoryLocation ilSrc;
		InventoryLocation ilDst;
		if (m_Lock && targetEntity == selectedEntity)
		{
			index = player.GetHumanInventory().FindUserReservedLocationIndex(m_Item);
			ilSrc = new InventoryLocation();
			ilDst = new InventoryLocation();
			
			m_Item.GetInventory().GetCurrentInventoryLocation(ilSrc);
			player.GetHumanInventory().GetUserReservedLocation(index, ilDst);
			
			if (ilDst.GetParent().GetInventory().LocationCanAddEntity(ilDst))
			{
			
				player.GetHumanInventory().ClearUserReservedLocation(m_Item);
				player.PredictiveTakeToDst(ilSrc, ilDst);
				m_Item.GetOnReleaseLock().Invoke(m_Item);
			}
		}
		else if (m_Lock)
		{
			CargoContainer parentCargo = CargoContainer.Cast(m_Parent);
			
			float parentX;
			float parentY;
			
			parentCargo.GetRootWidget().GetScreenPos(parentX, parentY);
			
			float iconSize = parentCargo.GetIconSize();
			float spaceSize = parentCargo.GetSpaceSize();
			
			int PosX = (x-parentX) / (iconSize + spaceSize);
			int PosY = (y-parentY) / (iconSize + spaceSize);
			
			EntityAI parent = m_Lock;
			CargoBase targetCargo = parent.GetInventory().GetCargo();
			
			ilDst = new InventoryLocation();			
			ilDst.SetCargoAuto(targetCargo, selectedEntity, PosY, PosX, selectedEntity.GetInventory().GetFlipCargo());
			
			if (parent.GetInventory().LocationCanAddEntity(ilDst))
			{
				player.GetHumanInventory().ClearUserReservedLocation(m_Item);
				m_Item.GetOnReleaseLock().Invoke(m_Item);
				
				SplitItemUtils.TakeOrSplitToInventoryLocation(player, ilDst);
			}
		}
		else
		{
			ilDst = new InventoryLocation();
			static int testedFlags = InventoryCombinationFlags.COMBINE_QUANTITY2 | InventoryCombinationFlags.ADD_AS_CARGO | InventoryCombinationFlags.ADD_AS_ATTACHMENT | InventoryCombinationFlags.SWAP | InventoryCombinationFlags.FSWAP | InventoryCombinationFlags.SWAP_MAGAZINE;
		
			int chosenInventoryAction = ItemManager.GetChosenCombinationFlag(selectedEntity, targetEntity, testedFlags, ilDst);
			PerformCombination(selectedEntity, targetEntity, chosenInventoryAction, ilDst);
		}		
	}

	void Swap( Widget w, int x, int y, Widget receiver )
	{
		ItemManager.GetInstance().HideDropzones();
		ItemManager.GetInstance().SetIsDragging(false);
		string name = w.GetName();
		name.Replace("PanelWidget", "Render");

		ItemPreviewWidget targetIpw = ItemPreviewWidget.Cast(receiver.FindAnyWidget( "Render" ));
		if (m_HandsIcon)
		{
			targetIpw = ItemPreviewWidget.Cast(receiver.GetParent().FindAnyWidget( "Render" ));
		}

		ItemPreviewWidget selectedIpw = ItemPreviewWidget.Cast(w.FindAnyWidget( name ));
		if (selectedIpw == null)
		{
			selectedIpw = ItemPreviewWidget.Cast(w.FindAnyWidget( "Render" ));
		}
		if (selectedIpw == null)
		{
			return;
		}

		InventoryItem targetEntity = InventoryItem.Cast(targetIpw.GetItem());
		InventoryItem selectedEntity = InventoryItem.Cast(selectedIpw.GetItem());
		if (!selectedEntity || !targetEntity)
		{
			return;
		}

		PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
		EntityAI itemInHands = player.GetHumanInventory().GetEntityInHands();

		InventoryLocation ilDst = new InventoryLocation();
		InventoryLocation ilSrc = new InventoryLocation();
		targetEntity.GetInventory().GetCurrentInventoryLocation(ilSrc);
		Icon icon = ItemManager.GetInstance().GetDraggedIcon();
		
		int index = player.GetHumanInventory().FindUserReservedLocationIndex(targetEntity);
		if (index>=0)
		{
			player.GetHumanInventory().GetUserReservedLocation(index, ilDst);

			if (GameInventory.CanForceSwapEntitiesEx( selectedEntity, ilSrc, targetEntity, ilDst ))
			{
				if (m_HandsIcon && !player.GetInventory().HasInventoryReservation(itemInHands, null) && !player.IsItemsToDelete())
				{
					GetGame().GetPlayer().PredictiveForceSwapEntities(selectedEntity, targetEntity, ilDst);
					return;
				}
			}
		}
		static int testedFlags = InventoryCombinationFlags.SWAP | InventoryCombinationFlags.FSWAP;
		
		int chosenInventoryAction = ItemManager.GetChosenCombinationFlag(selectedEntity, targetEntity, testedFlags, ilDst);
		PerformCombination(selectedEntity, targetEntity, chosenInventoryAction, ilDst);
	}

	void ToRefresh( Icon icon, Icon icon2 )
	{
		( IconsContainer.Cast( m_Parent ) ).RemoveItem( icon );
		( IconsContainer.Cast( m_Parent ) ).RemoveItem( icon2 );
	}

	override void SetLayoutName()
	{
		#ifdef PLATFORM_CONSOLE
			m_LayoutName = WidgetLayoutName.IconXbox;
		#else
			switch (InventoryMenu.GetWidthType())
			{
				case ScreenWidthType.NARROW:
				{
					m_LayoutName = WidgetLayoutName.IconNarrow;
					break;
				}
				case ScreenWidthType.MEDIUM:
				{
					m_LayoutName = WidgetLayoutName.IconMedium;
					break;
				}
				case ScreenWidthType.WIDE:
				{
					m_LayoutName = WidgetLayoutName.IconWide;
					break;
				}
			}
		#endif
			
	}

	void SetSize( int x, int y )
	{
		m_SizeX = x;
		m_SizeY = y;
	}
	
	void SetPos( int x, int y )
	{
		m_PosX = x;
		m_PosY = y;
	}

	int GetCargoPos()
	{
		return m_CargoPos;
	}

	void SetCargoPos(int x)
	{
		GetMainWidget().SetSort( x );
		m_CargoPos = x;
	}

	void DestroyWhiteBackground()
	{
		ItemManager.GetInstance().HideDropzones();
		ItemManager.GetInstance().SetIsDragging( false );
		m_IsDragged = false;
		
		RevertToOriginalFlip();
		
		if (m_HandsIcon)
		{
			m_ItemPreview.SetForceFlipEnable(true);
			m_ItemPreview.SetForceFlip(false);
			Refresh();
			FullScreen();
		}
		
		m_ColorWidget.Show(false);
		
		m_CursorWidget.SetColor( ARGBF( 1, 1, 1, 1 ) );
		m_CursorWidget.Show( false );

		InventoryMenu menu = InventoryMenu.Cast(GetGame().GetUIManager().FindMenu( MENU_INVENTORY ));
		
		if (menu)
			menu.RefreshQuickbar();
	}

	void CreateWhiteBackground()
	{
		m_PreviousFlipOrientation = m_Item.GetInventory().GetFlipCargo();
		ItemManager.GetInstance().SetDraggedIcon(this);
		ItemManager.GetInstance().SetDraggedItem(m_Item);
		m_IsDragged = true;
		ItemManager.GetInstance().SetIsDragging(true);
		int ww, hh;
		GetGame().GetInventoryItemSize(m_Item, ww, hh);
		if (m_Item.GetInventory().GetFlipCargo())
			SetSize(hh, ww);
		else
			SetSize(ww, hh);
		
		SetSize();
		
		if (!m_HandsIcon)
		{
			Refresh();
		}
		else
		{
			m_ItemPreview.SetForceFlipEnable(false);
			m_ColorWidget.SetColor(ColorManager.BASE_COLOR);
		}
		m_ColorWidget.Show(m_HandsIcon);
		
		m_CursorWidget.Show(true);
	}

	void OnDraggingOverBackground( Widget w, int x, int y, Widget reciever  )
	{
		ItemManager.GetInstance().HideDropzones();
		EntityAI entity = EntityAI.Cast( m_Obj );
		EntityAI parent = entity.GetHierarchyParent();
		if (parent && parent.GetHierarchyRootPlayer() == GetGame().GetPlayer())
		{
			ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
		}
		else if (!m_HandsIcon)
		{
			ItemManager.GetInstance().GetLeftDropzone().SetAlpha(1);
		}

		if (w == null || reciever == null)
		{
			return;
		}
		Pos pa;
		reciever.GetUserData(pa);
		if (m_Parent)
		{
			ContainerWithCargo item = ContainerWithCargo.Cast(m_Parent.m_Parent);
			if (item)
			{
				item.DraggingOverGrid(w, m_PosY + pa.y, m_PosX + pa.x, reciever);
			}
			HandsContainer hands_item = HandsContainer.Cast(m_Parent.m_Parent);
			if (hands_item)
			{
				hands_item.DraggingOverGrid(w, m_PosY + pa.y, m_PosX + pa.x, reciever, null);
			}
		}
	}

	void DropReceivedFromBackground( Widget w, int x, int y, Widget reciever  )
	{
		Pos pa;
		if (reciever)
		{
			reciever.GetUserData(pa);
			if (m_Parent)
			{
				ContainerWithCargo item = ContainerWithCargo.Cast(m_Parent.m_Parent);
				if (item)
				{
					item.DropReceived(w, m_PosY + pa.y, m_PosX + pa.x);
				}
			}
		}
	}
	
	void RevertToOriginalFlip()
	{
		if (m_Item)
		{
			m_Item.GetInventory().SetFlipCargo(m_PreviousFlipOrientation);
			int ww, hh;
			GetGame().GetInventoryItemSize(m_Item, ww, hh);
			
			if (m_PreviousFlipOrientation)
				SetSize(hh, ww);
			else
				SetSize(ww, hh);

			SetSize();
		}
	}

	override void Refresh()
	{
		super.Refresh();

		if (!m_HandsIcon)
			SetPos();
		
		if (m_HasTemperature)
			SetTemperature();
		
		if (m_IsWeapon)
			RefreshMuzzleIcon();
		
		if (m_HasQuantity)
			SetQuantity();
	}

	void SetTemperature()
	{
		ItemManager.GetInstance().SetIconTemperature(EntityAI.Cast( m_Obj ), m_RootWidget);
	}

	void RefreshIconPos()
	{
		Refresh();
		GetMainWidget().Update();
	}

	void FullScreen()
	{
		if (m_IsDragged)
		{
			return;
		}
		GetRootWidget().ClearFlags(WidgetFlags.HEXACTSIZE + WidgetFlags.VEXACTSIZE);
		GetRootWidget().SetSize(1, 1);
		m_ColorWidget.SetColor(ARGB( 0, 0, 0, 0 ));
	}

	void RefreshPos( int row, int column )
	{
		if (row != m_PosY || column != m_PosX)
		{
			m_PosX = column;
			m_PosY = row;
			SetPos();
			RefreshIconPos();
		}
	}

	Object GetObject()
	{
		return m_Obj;
	}
	
	void RefreshMuzzleIcon()
	{
		Weapon_Base wpn = Weapon_Base.Cast(GetObject());
		if (wpn)
		{
			int i;
			ImageWidget ammoIcon;
			if (!wpn.IsShowingChamberedBullet())
			{
				for (i = 0; i < m_AmmoIcons.Count(); i++)
				{
					ammoIcon = m_AmmoIcons.Get(i);
					ammoIcon.Show(false);
				}
			}
			else
			{
				for (i = 0; i < wpn.GetMuzzleCount(); i++)
				{
					if (i > m_AmmoIcons.Count())
						break;
					
					ammoIcon = m_AmmoIcons.Get(i);
					
					if (wpn.IsChamberFull(i))
					{
						if (wpn.IsJammed())
						{
							ammoIcon.Show(true);
							ammoIcon.SetImage(2);
						}
						else if (wpn.IsChamberFiredOut(i))
						{
							ammoIcon.Show(true);
							ammoIcon.SetImage(1);
						}
						else
						{
							ammoIcon.Show(true);
							ammoIcon.SetImage(0);
						}
					}
					else
					{
						ammoIcon.Show(false);
					}
				}
			}
		}
	}
	
	void SetQuantity()
	{
		if (m_Item)
		{
			int quantityType = QuantityConversions.HasItemQuantity(m_Item);
			if (quantityType != QUANTITY_HIDDEN && m_CurrQuantity != QuantityConversions.GetItemQuantity(m_Item))
			{
				m_CurrQuantity = QuantityConversions.GetItemQuantity(m_Item);
			
				if (quantityType == QUANTITY_COUNT)
				{
					string quantityText = QuantityConversions.GetItemQuantityText(m_Item);

					if (QuantityConversions.GetItemQuantityMax(m_Item) == 1 || quantityText == "")
					{
						m_QuantityStack.Show(false);
					}
					else
					{
						m_QuantityItem.SetText(quantityText);
						m_QuantityStack.Show(true);
					}

					m_QuantityProgress.Show(false);
				}
				else if (quantityType == QUANTITY_PROGRESS)
				{	
					int max 			= m_Item.GetQuantityMax();
					int count 			= m_Item.ConfigGetInt("count");
					float quantity		= m_CurrQuantity;
	
					if (count > 0)
					{
						max = count;
					}
					
					if (max > 0)
					{
						float value = Math.Round((quantity / max) * 100);
						m_QuantityProgress.SetCurrent(value);
					}

					m_QuantityStack.Show(false);
					m_QuantityProgress.Show(true);
				}
			}
		}
	}
	
	void SetSort(int index)
	{
		GetMainWidget().SetSort(index);
		GetMainWidget().Update();
	}
	
	int GetSort()
	{
		return GetMainWidget().GetSort();
	}
	
	void SetItemPreviewEx(bool refresh = true)
	{
		m_ItemPreview.Show(true, refresh);
		m_ItemPreview.SetItem(EntityAI.Cast(m_Obj));
		m_ItemPreview.SetModelOrientation("0 0 0");
		m_ItemPreview.SetView(m_Obj.GetViewIndex());
	}
	
	void SetItemPreview()
	{
		SetItemPreviewEx();
	}
	
	void SetItemSizeEx(bool refresh = true)
	{
		#ifdef PLATFORM_CONSOLE
		m_ItemSizePanel.Show(true, refresh);
		m_ItemSizeWidget.Show(true, refresh);
		
		int sizeX, sizeY;
		GetGame().GetInventoryItemSize(m_Item, sizeX, sizeY);
		int capacity = sizeX * sizeY;
		m_ItemSizeWidget.SetText(capacity.ToString());
		#endif
	}
	
	void SetItemSize()
	{
		SetItemSizeEx();
	}
	
	void UpdateFlip(bool flipped)
	{
		int sizeX, sizeY;
		GetGame().GetInventoryItemSize(m_Item, sizeX, sizeY);
		
		if (flipped)
			SetSize(sizeY, sizeX);
		else
			SetSize(sizeX, sizeY);

		SetSize();
	}
	
	void InitLock( EntityAI parent, EntityAI obj, int x_pos, int y_pos, bool flip)
	{
		m_Lock	= parent;
		m_Obj	= obj;
		m_Item	= ItemBase.Cast(m_Obj);
		
		SetPos(x_pos, y_pos);
		UpdateFlip( flip );
		
		ItemManager.GetInstance().SetWidgetDraggable( GetMainWidget(), false );
		WidgetEventHandler.GetInstance().RegisterOnMouseButtonDown( GetMainWidget(), this, "MouseClick" );
		WidgetEventHandler.GetInstance().RegisterOnDropReceived( GetMainWidget(),  this, "DropReceivedFromMain" );
		WidgetEventHandler.GetInstance().RegisterOnDraggingOver( GetMainWidget(),  this, "DraggingOver" );
		
		m_RootWidget.FindAnyWidget( "Reserved" ).Show( true );
		m_ItemPreview.SetForceFlipEnable(true);
		m_ItemPreview.SetForceFlip(flip);
		SetItemPreview();
		Refresh();
	}

	void InitEx( EntityAI obj, bool refresh = true )
	{
		if (obj != m_Obj)
		{
			if (m_Obj)
			{
				m_Obj.GetOnItemFlipped().Remove(UpdateFlip );
				m_Obj.GetOnViewIndexChanged().Remove(SetItemPreview);
			}
			if (obj)
			{
				obj.GetOnItemFlipped().Insert(UpdateFlip);
				obj.GetOnViewIndexChanged().Insert(SetItemPreview);
			}
		}
		
		if (m_HandsIcon)
		{
			m_ItemPreview.SetForceFlipEnable(true);
			m_ItemPreview.SetForceFlip(false);
		}
		
		m_Obj	= obj;
		m_Item	= ItemBase.Cast(m_Obj);
		m_Lock = null;
		
		SetItemPreviewEx(refresh);
		
		WidgetEventHandler.GetInstance().RegisterOnDrag( GetMainWidget(),  this, "CreateWhiteBackground" );
		WidgetEventHandler.GetInstance().RegisterOnDrop( GetMainWidget(),  this, "DestroyWhiteBackground" );
		WidgetEventHandler.GetInstance().RegisterOnDropReceived( GetMainWidget(),  this, "DropReceivedFromMain" );
		WidgetEventHandler.GetInstance().RegisterOnMouseButtonDown( GetMainWidget(),  this, "MouseClick" );
		WidgetEventHandler.GetInstance().RegisterOnDropReceived( GetMainWidget().FindAnyWidget( "Swap" ),  this, "Swap" );
		WidgetEventHandler.GetInstance().RegisterOnDraggingOver( GetMainWidget().FindAnyWidget( "Swap" ),  this, "DraggingOverSwap" );
		WidgetEventHandler.GetInstance().RegisterOnDropReceived( GetMainWidget().FindAnyWidget( "Combine" ),  this, "Combine" );
		WidgetEventHandler.GetInstance().RegisterOnDraggingOver( GetMainWidget().FindAnyWidget( "Combine" ),  this, "DraggingOverCombine" );
		WidgetEventHandler.GetInstance().RegisterOnDraggingOver( GetMainWidget(),  this, "DraggingOver" );
		WidgetEventHandler.GetInstance().RegisterOnMouseEnter( GetMainWidget(),  this, "MouseEnter" );
		WidgetEventHandler.GetInstance().RegisterOnMouseLeave( GetMainWidget(),  this, "MouseLeave" );
		WidgetEventHandler.GetInstance().RegisterOnDoubleClick( GetMainWidget(),  this, "DoubleClick" );
		
		SetItemSizeEx(refresh);
		CheckIsWeapon();
		CheckIsMagazineEx(refresh);
		CheckHasTemperature();
		CheckHasQuantityEx(refresh);
		m_RootWidget.FindAnyWidget("Reserved").Show(false, refresh);
		
		m_ColorWidget.Show(false);
		if (refresh)
			Refresh();
	}
	
	void Init(EntityAI obj)
	{
		InitEx(obj);
	}
	
	void CheckIsWeapon()
	{
		Weapon_Base wpn = Weapon_Base.Cast(m_Obj);
		if (wpn)
		{
			m_AmmoIcons = new array<ImageWidget>();
			m_IsWeapon = true;
			float posX = 0.0;
			float width = 0.0, height = 0.0;
			for (int i = 0; i < wpn.GetMuzzleCount(); i++)
			{
				if (i == 1)
				{
					m_AmmoIcons[0].GetSize(width, height);
				}
				posX += width;
				
				Widget ammoIcon = Widget.Cast(GetGame().GetWorkspace().CreateWidgets("gui/layouts/inventory_new/ammo_icon.layout", GetMainWidget()));
				ammoIcon.SetPos(posX, 0.0, false);
				
				ImageWidget ammoIconImg = ImageWidget.Cast(ammoIcon.GetChildren());				
				
				AmmoData data = Magazine.GetAmmoData(wpn.GetChamberAmmoTypeName(i));
				if (data)
				{
					CartridgeType cartridgeType = data.m_CartridgeType;
					switch (cartridgeType)
					{
						case CartridgeType.Pistol:
						{
							ammoIconImg.LoadImageFile(0, "set:dayz_gui image:cartridge_pistol");
							ammoIconImg.LoadImageFile(1, "set:dayz_gui image:shell_pistol");
							ammoIconImg.LoadImageFile(2, "set:dayz_gui image:jam_pistol");
							break;
						}
						case CartridgeType.Intermediate:
						{
							ammoIconImg.LoadImageFile(0, "set:dayz_gui image:cartridge_int");
							ammoIconImg.LoadImageFile(1, "set:dayz_gui image:shell_int");
							ammoIconImg.LoadImageFile(2, "set:dayz_gui image:jam_int");
							break;
						}
						case CartridgeType.FullPower:
						{
							ammoIconImg.LoadImageFile(0, "set:dayz_gui image:cartridge_fp");
							ammoIconImg.LoadImageFile(1, "set:dayz_gui image:shell_fp");
							ammoIconImg.LoadImageFile(2, "set:dayz_gui image:jam_fp");
							break;
						}
						case CartridgeType.Shell:
						{
							ammoIconImg.LoadImageFile(0, "set:dayz_gui image:cartridge_shell");
							ammoIconImg.LoadImageFile(1, "set:dayz_gui image:shell_shell");
							ammoIconImg.LoadImageFile(2, "set:dayz_gui image:jam_shell");
							break;
						}
						//@note: Crossbows cant jam so we dont add a icon for the jam state
						case CartridgeType.Arrow:
						{
							ammoIconImg.LoadImageFile(0, "set:dayz_gui image:arrow_int");
							ammoIconImg.LoadImageFile(1, "set:dayz_gui image:arrow_int");
							break;
						}
					}
				}
				m_AmmoIcons.Insert(ammoIconImg);
			}
		}
		else
		{
			m_IsWeapon = false;
		}			
	}
	
	void CheckIsMagazineEx( bool refresh = true )
	{
		Magazine mag = Magazine.Cast(m_Obj);
		if (mag)
		{
			m_IsMagazine = true;
			AmmoData data = Magazine.GetAmmoData(mag.ClassName());
			if (data)
			{
				ProjectileType p_type = data.m_ProjectileType;
				switch (p_type)
				{
					case ProjectileType.None:
					{
						m_AmmoTypeIcon.Show(false, refresh);
						break;
					}
					case ProjectileType.Tracer:
					{
						m_AmmoTypeIcon.LoadImageFile(0, "set:dayz_gui image:tracer");
						m_AmmoTypeIcon.Show(true, refresh);
						break;
					}
					case ProjectileType.AP:
					{
						m_AmmoTypeIcon.LoadImageFile(0, "set:dayz_gui image:armor_piercing");
						m_AmmoTypeIcon.Show(true, refresh);
						break;
					}
				}
			}
		}
		else
		{
			m_IsMagazine = false;
		}
	}
	
	void CheckIsMagazine()
	{
		CheckIsMagazineEx();
	}
	
	void CheckHasTemperature()
	{
		if (m_Item)
		{
			m_HasTemperature = m_Item.CanHaveTemperature();
		}
	}
	
	void CheckHasQuantityEx(bool refresh = true)
	{
		if (m_Item)
		{
			m_HasQuantity = (QuantityConversions.HasItemQuantity( m_Item ) != QUANTITY_HIDDEN);
			
			if (m_HasQuantity)
				m_QuantityPanel.Show(true, refresh);
		}
	}
	
	void CheckHasQuantity()
	{
		CheckHasQuantityEx();
	}
	
	void SetPosX(int x)
	{
		m_PosX = x;
	}
	
	void SetPosY(int y)
	{
		m_PosY = y;
	}
	
	void SetSizeX(int x)
	{
		m_SizeX = x;
	}
	
	void SetSizeY(int y)
	{
		m_SizeY = y;
	}
	
	int GetPosX()
	{
		return m_PosX;
	}
	
	int GetPosY()
	{
		return m_PosY;
	}
	
	int GetSizeX()
	{
		return m_SizeX;
	}
	
	int GetSizeY()
	{
		return m_SizeY;
	}

	void SetPosEx(bool refresh = true)
	{
		CargoContainer parentContainer = CargoContainer.Cast(m_Parent);
		HandsPreview parentHPrevContainer = HandsPreview.Cast(m_Parent);
		Widget rootWidget = GetRootWidget();
		float iconSize, spaceSize;
		if (parentContainer)
		{
			iconSize = parentContainer.GetIconSize();
			spaceSize = parentContainer.GetSpaceSize();
		}
		else if (parentHPrevContainer)
		{
			iconSize = parentHPrevContainer.GetIconSize();
			if (rootWidget)
			{
				rootWidget.SetFlags(WidgetFlags.EXACTSIZE, refresh);
			}
		}
		
		if (rootWidget)
		{
			#ifndef PLATFORM_CONSOLE
				rootWidget.SetPos(iconSize * GetPosX() + ( GetPosX() + 1 ) * spaceSize, iconSize * GetPosY() + ( GetPosY() + 1 ) * spaceSize, refresh);
				rootWidget.SetSize(iconSize * m_SizeX + ( m_SizeX ) * spaceSize, iconSize * m_SizeY + ( m_SizeY ) * spaceSize, refresh);
			#else
				int row = m_CargoPos / 5;
				int column = m_CargoPos % 5;
				rootWidget.SetPos(iconSize * column, iconSize * row, refresh);
				rootWidget.SetSize(iconSize, iconSize, refresh);
			#endif
		}
	}
	
	void SetPos()
	{
		SetPosEx();
	}
	
	void SetSize()
	{
		CargoContainer parentContainer = CargoContainer.Cast(m_Parent);
		HandsPreview parentHPrevContainer = HandsPreview.Cast(m_Parent);
		float iconSize, spaceSize;
		Widget rootWidget = GetRootWidget();
		if (parentContainer)
		{
			iconSize = parentContainer.GetIconSize();
			spaceSize = parentContainer.GetSpaceSize();
		}
		else if (parentHPrevContainer)
		{
			iconSize = parentHPrevContainer.GetIconSize();
			if (rootWidget)
			{
				GetRootWidget().SetFlags(WidgetFlags.EXACTSIZE);
			}
		}
	
		if (rootWidget)
		{
		#ifndef PLATFORM_CONSOLE
			GetRootWidget().SetSize(iconSize * m_SizeX + ( m_SizeX ) * spaceSize, iconSize * m_SizeY + ( m_SizeY ) * spaceSize);
		#else
			GetRootWidget().SetSize(iconSize, iconSize);
		#endif
		}
	}
	
	override void UpdateInterval()
	{
		if (m_Item)
		{
			if (m_HasTemperature)
				SetTemperature();
			
			if (m_IsWeapon)
				RefreshMuzzleIcon();
			
			if (m_HasQuantity)
				SetQuantity();
		}
	}
}

class Pos
{
	int x, y;

	void Pos(int _x, int _y)
	{
		x = _x;
		y = _y;
	}
}