icon.c

Go to the documentation of this file.

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);
 }
 
 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 inventoryLocation = new InventoryLocation();
 int index = controlledPlayer.GetHumanInventory().FindUserReservedLocationIndex(entityInHands);
 if (index >= 0)
 controlledPlayer.GetHumanInventory().GetUserReservedLocation(index, inventoryLocation);
 
 if (controlledPlayer.GetInventory().CanForceSwapEntitiesEx(targetEntity, null, entityInHands, inventoryLocation))
 {
 controlledPlayer.PredictiveForceSwapEntities(targetEntity, entityInHands, inventoryLocation);
 }
 else if (controlledPlayer.GetInventory().CanSwapEntitiesEx(targetEntity, entityInHands ))
 {
 controlledPlayer.PredictiveSwapEntities(targetEntity, entityInHands);
 }
 else
 {
 controlledPlayer.GetInventory().FindFreeLocationFor(targetEntity, FindInventoryLocationType.ANY, inventoryLocation);
 if (inventoryLocation.IsValid() && controlledPlayer.GetInventory().LocationCanAddEntity(inventoryLocation))
 SplitItemUtils.TakeOrSplitToInventoryLocation(controlledPlayer, inventoryLocation);
 }
 }
 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:
 float stackable = targetEntity.GetTargetQuantityMax(-1);
 
 if (stackable == 0 || stackable >= targetEntity.GetQuantity())
 {
 return player.PredictiveTakeEntityToTargetAttachment(targetEntity, selectedEntity);
 }
 else
 {
 InventoryLocation il = new InventoryLocation();
 targetEntity.GetInventory().FindFreeLocationFor(selectedEntity, FindInventoryLocationType.ATTACHMENT, il);
 ItemBase.Cast(selectedEntity).SplitIntoStackMaxToInventoryLocationClient(il);
 return true;
 }
 break;
 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 && m_Item.IsItemBase())
 {
 m_Item.OnRightClick();
 
 if (m_HasQuantity)
 SetQuantity();
 #ifdef DIAG_DEVELOPER
 if (GetDayZGame().IsLeftCtrlDown())
 ShowActionMenu(m_Item);
 #endif
 }
 }
 
 }
 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_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.SetAlpha(0.1);
 }
 
 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);
 }
 /* int bullet_count = 0;
 int fireout_count = 0;
 
 for ( i = 0; i < wpn.GetMuzzleCount(); i++ )
 {
 if (wpn.IsChamberFull(i))
 {
 if (wpn.IsChamberFiredOut(i))
 {
 fireout_count++;
 }
 else
 {
 bullet_count++;
 }
 }
 }
 
 int j;
 i = 0;
 for ( j= 0; j < bullet_count; j++ )
 {
 if ( i > m_AmmoIcons.Count() )
 {
 //add plus ammo
 break;
 }
 
 ammoIcon = m_AmmoIcons.Get(i);
 ammoIcon.Show( true );
 ammoIcon.SetImage( 0 );
 i++;
 }
 
 for ( j= 0; j < fireout_count; j++ )
 {
 if ( i > m_AmmoIcons.Count() )
 {
 //add plus ammo
 break;
 }
 
 ammoIcon = m_AmmoIcons.Get(i);
 ammoIcon.Show( true );
 ammoIcon.SetImage( 1 );
 i++;
 }
 
 for (j = i; j < m_AmmoIcons.Count(); j++)
 {
 ammoIcon = m_AmmoIcons.Get(j);
 ammoIcon.Show(false);
 }*/
 }
 else
 {
 //TODO MW - add more conplex logic
 for (i = 0; i < wpn.GetMuzzleCount(); i++)
 {
 if ( i > m_AmmoIcons.Count() )
 {
 //add plus ammo
 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);
 
 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 widht = 0.0, height = 0.0; 
 for (int i = 0; i < wpn.GetMuzzleCount(); i++)
 {
 if (i == 1)
 {
 m_AmmoIcons[0].GetSize(widht,height);
 }
 posX += widht;
 
 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 c_type = data.m_CartridgeType;
 switch (c_type)
 {
 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;
 }
 }
 }
 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.GetTemperatureMax() != 0 && m_Item.GetTemperatureMin() != 0);
 }
 }
 
 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;
 }
}