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;
  }
}