CargoContainer.c

Go to the documentation of this file.

//cargo grid wrapper
class CargoContainer extends Container
{
  protected const int ROWS_NUMBER_XBOX = 5;
 
  protected CargoBase m_Cargo;
  protected int m_CargoIndex = -1;
 
  protected int m_FocusedItemPosition = -1;
  protected ref array<ref CargoContainerRow> m_Rows;
  protected ref array<ref Icon> m_Icons;
  protected ref map<EntityAI, ref Param3<ref Icon, int, int>> m_ShowedItemPositions;
  protected ref map<EntityAI, ref Param3<ref Icon, int, int>> m_ShowedLockPositions;
 
  protected float m_IconSize;
  protected float m_SpaceSize;
 
  protected bool m_IsAttachment;
  protected TextWidget m_FalseHeaderTextWidget;
  protected TextWidget m_AlternateFalseHeaderTextWidget; //to be set and updated along with the main one
  protected Widget m_CargoHeader;
  protected Widget m_CargoContainer;
  protected Widget m_ItemsContainer;
#ifndef PLATFORM_CONSOLE
  protected ref SizeToChild m_Resizer1;
#endif
  protected ref SizeToChild m_Resizer2;
  protected ref Timer m_ResizeTimer;
 
  void CargoContainer(LayoutHolder parent, bool is_attachment = false)
  {
    m_IsAttachment = is_attachment;
    m_Rows = new array<ref CargoContainerRow>;
    m_Icons = new array<ref Icon>;
    m_ShowedItemPositions = new map<EntityAI, ref Param3<ref Icon, int, int>>;
    m_ShowedLockPositions = new map<EntityAI, ref Param3<ref Icon, int, int>>;
 
    m_CargoContainer = m_RootWidget.FindAnyWidget("grid_background");
    m_ItemsContainer = m_RootWidget.FindAnyWidget("grid_overlay");
    m_CargoHeader = m_RootWidget.FindAnyWidget("grid_container_header_spacer");
#ifndef PLATFORM_CONSOLE
    m_RootWidget.GetScript(m_Resizer1);
#endif
    m_RootWidget.FindAnyWidget("grid_container").GetScript(m_Resizer2);
    m_CargoHeader.Show(is_attachment);
    m_FalseHeaderTextWidget = TextWidget.Cast(m_CargoHeader.FindAnyWidget("TextWidget0"));
 
    m_MainWidget = m_CargoContainer;
    m_FocusedItemPosition = -1;
  }
 
  void ~CargoContainer()
  {
    if (m_Entity)
    {
      m_Entity.GetOnItemAddedIntoCargo().Remove(AddedToCargo);
      m_Entity.GetOnItemRemovedFromCargo().Remove(RemovedFromCargo);
      m_Entity.GetOnItemMovedInCargo().Remove(MovedInCargo);
      m_Entity.GetOnSetLock().Remove(SetLock);
      m_Entity.GetOnReleaseLock().Remove(ReleaseLock);
    }
  }
 
  int GetCargoIndex() { return m_CargoIndex; }
 
  void AddedToCargoEx(EntityAI item, bool refresh = true)
  {
    InventoryLocation il = new InventoryLocation;
    item.GetInventory().GetCurrentInventoryLocation(il);
    int x = il.GetCol();
    int y = il.GetRow();
 
    if (m_ShowedItemPositions.Contains(item))
    {
      Param3<ref Icon, int, int> item_pos = m_ShowedItemPositions.Get(item);
      InitIconEx(item_pos.param1, item, x, y, refresh);
      item_pos.param2 = x;
      item_pos.param3 = y;
    }
    else
    {
      ref Icon icon = new Icon(this, false);
      m_Icons.Insert(icon);
      InitIconEx(icon, item, x, y, refresh);
      m_ShowedItemPositions.Insert(item, new Param3<ref Icon, int, int>(icon, x, y));
    }
 
    if (refresh)
      UpdateHeaderText();
 
#ifdef PLATFORM_CONSOLE
    for (int i = 0; i < m_Cargo.GetItemCount(); i++)
    {
      EntityAI item2 = m_Cargo.GetItem(i);
      Param3<ref Icon, int, int> data = m_ShowedItemPositions.Get(item2);
      if (data)
      {
        data.param1.SetCargoPos(i);
        data.param1.SetPos();
      }
    }
 
    m_FocusedItemPosition = Math.Min(m_ShowedItemPositions.Count() - 1, m_FocusedItemPosition);
 
    if (refresh)
      Refresh();
#endif
  }
 
  void AddedToCargo(EntityAI item)
  {
    AddedToCargoEx(item);
  }
 
  void RemovedFromCargo(EntityAI item)
  {
    Param3<ref Icon, int, int> data = m_ShowedItemPositions.Get(item);
    if (data)
    {
      m_Icons.RemoveItem(data.param1);
      m_ShowedItemPositions.Remove(item);
    }
 
    UpdateHeaderText();
 
#ifdef PLATFORM_CONSOLE
    for (int i = 0; i < m_Cargo.GetItemCount(); i++)
    {
      EntityAI item2 = m_Cargo.GetItem(i);
      data = m_ShowedItemPositions.Get(item2);
      if (data && data.param1)
      {
        data.param1.SetCargoPos(i);
        data.param1.SetPos();
      }
    }
 
    m_FocusedItemPosition = Math.Min(m_ShowedItemPositions.Count() - 1, m_FocusedItemPosition);
 
    Refresh();
#endif
  }
 
  void MovedInCargo(EntityAI item)
  {
    InventoryLocation il = new InventoryLocation;
    item.GetInventory().GetCurrentInventoryLocation(il);
 
    int x = il.GetCol();
#ifdef PLATFORM_CONSOLE
    int y = il.GetRow() - 1;
#else
    int y = il.GetRow();
#endif
    if (m_ShowedItemPositions.Contains(item))
    {
      ref Param3<ref Icon, int, int> data = m_ShowedItemPositions.Get(item);
      if (data.param1)
      {
        if (data.param2 != x || data.param3 != y)
        {
          data.param2 = x;
          data.param3 = y;
#ifdef PLATFORM_CONSOLE
          data.param1.SetCargoPos(data.param3);
#endif
#ifdef PLATFORM_WINDOWS
          data.param1.SetPosX(data.param2);
          data.param1.SetPosY(data.param3);
#endif
        }
        data.param1.UpdateInterval();
      }
    }
    UpdateSelection();
  }
 
  void SetLock(EntityAI item)
  {
#ifndef PLATFORM_CONSOLE
    if (GetGame().GetPlayer())
    {
      InventoryLocation il = new InventoryLocation;
      int index = GetGame().GetPlayer().GetHumanInventory().FindUserReservedLocationIndex(item);
      if (index >= 0)
      {
        GetGame().GetPlayer().GetHumanInventory().GetUserReservedLocation(index, il);
 
        ref Icon icon = new Icon(this, false);
        m_Icons.Insert(icon);
        icon.InitLock(m_Entity, item, il.GetCol(), il.GetRow(), il.GetFlip());
        m_ShowedLockPositions.Insert(item, new Param3<ref Icon, int, int>(icon, 1, 1));
        item.GetOnReleaseLock().Insert(ReleaseLock);
      }
    }
#endif
  }
 
  void ReleaseLock(EntityAI item)
  {
#ifndef PLATFORM_CONSOLE
    if (m_ShowedLockPositions.Contains(item))
    {
      Icon ic = m_ShowedLockPositions.Get(item).param1;
      m_Icons.RemoveItem(ic);
      m_ShowedLockPositions.Remove(item);
      item.GetOnReleaseLock().Remove(ReleaseLock);
    }
#endif
  }
 
  override void SetLayoutName()
  {
#ifdef PLATFORM_CONSOLE
    m_LayoutName = WidgetLayoutName.CargoContainerXbox;
#else
    switch (InventoryMenu.GetWidthType())
    {
    case ScreenWidthType.NARROW:
    {
      m_LayoutName = WidgetLayoutName.CargoContainerNarrow;
      break;
    }
    case ScreenWidthType.MEDIUM:
    {
      m_LayoutName = WidgetLayoutName.CargoContainerMedium;
      break;
    }
    case ScreenWidthType.WIDE:
    {
      m_LayoutName = WidgetLayoutName.CargoContainerWide;
      break;
    }
    }
#endif
 
  }
 
  void SetEntity(EntityAI item, int cargo_index = 0, bool immedUpdate = true)
  {
    if (item)
    {
      m_Entity = item;
      m_Cargo = item.GetInventory().GetCargoFromIndex(cargo_index);
      m_CargoIndex = cargo_index;
 
      m_Entity.GetOnItemAddedIntoCargo().Insert(AddedToCargo);
      m_Entity.GetOnItemRemovedFromCargo().Insert(RemovedFromCargo);
      m_Entity.GetOnItemMovedInCargo().Insert(MovedInCargo);
      m_Entity.GetOnSetLock().Insert(SetLock);
      m_Entity.GetOnReleaseLock().Insert(ReleaseLock);
 
      if (immedUpdate)
        UpdateHeaderText();
 
      InitGridHeight();
      m_MainWidget = m_ItemsContainer;
 
      if (m_Cargo)
      {
        int i;
        int prev_count = m_ShowedItemPositions.Count();
 
        //START - Add new item Icons
        for (i = 0; i < m_Cargo.GetItemCount(); i++)
        {
          EntityAI cargo_item = m_Cargo.GetItem(i);
          if (cargo_item)
            AddedToCargoEx(cargo_item, immedUpdate);
        }
 
#ifdef PLATFORM_CONSOLE
        if (immedUpdate)
          Refresh();
#endif
      }
    }
  }
 
  EntityAI GetEntity()
  {
    return m_Entity;
  }
 
  void UpdateHeaderText()
  {
    Widget header;
    string name = m_Entity.GetDisplayName();
    name.ToUpper();
 
    if (m_Entity.CanDisplayCargo() && m_Entity.GetInventory().GetCargoFromIndex(m_CargoIndex))
    {
      name = name + " (" + GetCargoCapacity().ToString() + "/" + GetMaxCargoCapacity() + ")";
      if (m_IsAttachment && m_CargoHeader)
      {
        m_FalseHeaderTextWidget.SetText(name);
        float x, y;
        m_FalseHeaderTextWidget.Update();
        m_FalseHeaderTextWidget.GetScreenSize(x, y);
        m_CargoHeader.FindAnyWidget("grid_container_header").SetSize(1, y + InventoryMenu.GetHeightMultiplied(10));
        m_CargoHeader.Update();
 
        if (m_AlternateFalseHeaderTextWidget)
          m_AlternateFalseHeaderTextWidget.SetText(name);
        return;
      }
    }
 
    if (Container.Cast(GetParent()) && Container.Cast(GetParent()).GetHeader())
      Container.Cast(GetParent()).GetHeader().SetName(name);
  }
 
  void InitGridHeight()
  {
    m_Rows.Clear();
    m_ShowedItemPositions.Clear();
 
    ref CargoContainerRow row;
 
#ifdef PLATFORM_CONSOLE
    int cargo_height = 1;
#else
    int cargo_height = m_Entity.GetInventory().GetCargoFromIndex(m_CargoIndex).GetHeight();
#endif
 
    for (int j = 0; j < cargo_height; j++)
    {
      row = new CargoContainerRow(this);
 
      row.SetNumber(j);
      row.SetEntity(m_Entity);
 
#ifdef PLATFORM_WINDOWS
#ifndef PLATFORM_CONSOLE
      row.SetWidth(m_Entity.GetInventory().GetCargoFromIndex(m_CargoIndex).GetWidth(), false);
#endif
#endif
 
      row.GetRootWidget().SetSort(j, false);
      m_Rows.Insert(row);
    }
 
    float y;
    row.GetRootWidget().FindAnyWidget("Icon0").GetScreenSize(y, m_IconSize);
#ifdef PLATFORM_WINDOWS
#ifndef PLATFORM_CONSOLE
    row.GetRootWidget().FindAnyWidget("Spacer0").GetScreenSize(m_SpaceSize, y);
#endif
#endif
 
    m_Resizer2.ResizeParentToChild();
#ifndef PLATFORM_CONSOLE
    m_Resizer1.ResizeParentToChild();
#endif
  }
 
  void UpdateSize()
  {
#ifndef PLATFORM_CONSOLE
    m_Resizer1.ResizeParentToChild();
#else
    m_Resizer2.ResizeParentToChild();
#endif
  }
 
  float GetIconSize()
  {
    return m_IconSize;
  }
 
  float GetSpaceSize()
  {
    return m_SpaceSize;
  }
 
  int GetCargoCapacity()
  {
#ifdef PLATFORM_CONSOLE
#ifndef PLATFORM_WINDOWS
    return CargoList.Cast(m_Cargo).GetTotalWeight(null);
#endif
#endif
    int total_size = 0;
    for (int i = 0; i < m_Cargo.GetItemCount(); ++i)
    {
      int x, y;
      m_Cargo.GetItemSize(i, x, y);
      total_size += x * y;
    }
    return total_size;
  }
 
  int GetMaxCargoCapacity()
  {
#ifdef PLATFORM_CONSOLE
#ifndef PLATFORM_WINDOWS
    return CargoList.Cast(m_Cargo).GetMaxWeight();
#endif
#endif
    return m_Cargo.GetWidth() * m_Cargo.GetHeight();
  }
 
  Icon GetIcon(EntityAI item)
  {
    if (item && m_ShowedItemPositions.Contains(item))
    {
      Param3<ref Icon, int, int> data = m_ShowedItemPositions.Get(item);
      return data.param1;
    }
    return null;
  }
 
  Icon GetIcon(int index)
  {
    if (m_Cargo == null)
      return null;
 
    if (index >= 0 && m_Cargo.GetItemCount() > index)
      return GetIcon(m_Cargo.GetItem(index));
    return null;
  }
 
  Icon GetFocusedIcon()
  {
    return GetIcon(m_FocusedItemPosition);
  }
 
  override float GetFocusedContainerHeight(bool contents = false)
  {
    float x, y;
    if (contents && GetFocusedIcon())
      GetFocusedIcon().GetRootWidget().GetScreenSize(x, y);
    else
      GetRootWidget().GetScreenSize(x, y);
    return y;
  }
 
  override float GetFocusedContainerYPos(bool contents = false)
  {
    float x, y;
    if (contents && GetFocusedIcon())
      GetFocusedIcon().GetRootWidget().GetPos(x, y);
    else
      GetRootWidget().GetPos(x, y);
    return y;
  }
 
  override float GetFocusedContainerYScreenPos(bool contents = false)
  {
    float x, y;
    if (contents && GetFocusedIcon())
      GetFocusedIcon().GetRootWidget().GetScreenPos(x, y);
    else
      GetRootWidget().GetScreenPos(x, y);
    return y;
  }
 
  void UpdateSelection()
  {
    if (m_IsActive)
    {
      if (m_FocusedItemPosition >= m_Icons.Count())
        m_FocusedItemPosition = m_Icons.Count() - 1;
      Icon icon = GetIcon(m_FocusedItemPosition);
      if (icon && !icon.IsActive())
      {
        icon.SetActive(true);
        Inventory.GetInstance().UpdateConsoleToolbar();
      }
    }
  }
 
  void UpdateRowVisibility(int count)
  {
    int i;
    int rows = Math.Max(1, Math.Ceil((count + 1) / ROWS_NUMBER_XBOX));
    int diff = rows - m_Rows.Count();
 
    if (diff < 0)
    {
      for (i = m_Rows.Count() - 1; i >= rows; i--)
        m_Rows.Remove(i);
    }
    else if (diff > 0)
    {
      m_MainWidget = m_CargoContainer;
      for (i = m_Rows.Count(); i < rows; i++)
      {
        ref CargoContainerRow row = new CargoContainerRow(this);
 
        row.SetNumber(i);
        row.SetEntity(m_Entity);
        row.GetRootWidget().SetSort(i);
        m_Rows.Insert(row);
      }
      m_MainWidget = m_ItemsContainer;
    }
 
    m_Resizer2.ResizeParentToChild();
#ifndef PLATFORM_CONSOLE
    m_Resizer1.ResizeParentToChild();
#endif
  }
 
  override void Refresh()
  {
#ifdef PLATFORM_CONSOLE
    if (!m_ResizeTimer)
      m_ResizeTimer = new Timer();
    if (m_ResizeTimer.IsRunning())
      m_ResizeTimer.Stop();
    m_ResizeTimer.Run(0.05, this, "RefreshImpl");
#endif
  }
 
  void RefreshImpl()
  {
    UpdateRowVisibility(m_ShowedItemPositions.Count());
    UpdateSelection();
  }
 
  override void UpdateInterval()
  {
    foreach (Param3<ref Icon, int, int> data : m_ShowedItemPositions)
    {
      if (data.param1)
        data.param1.UpdateInterval();
    }
  }
 
  Icon InitIconEx(Icon icon, EntityAI item, int pos_x, int pos_y, bool refresh = true)
  {
#ifdef PLATFORM_CONSOLE
    icon.SetSize(1, 1);
#ifdef PLATFORM_WINDOWS
    pos_y = pos_y * 5 + pos_x;
#endif
    icon.SetCargoPos(pos_y);
    icon.SetPosY(pos_y);
    icon.SetPosEx(refresh);
#else
    int size_x, size_y;
    GetGame().GetInventoryItemSize(InventoryItem.Cast(item), size_x, size_y);
 
    if (item.GetInventory().GetFlipCargo())
      icon.SetSize(size_y, size_x);
    else
      icon.SetSize(size_x, size_y);
 
    icon.SetPosX(pos_x);
    icon.SetPosY(pos_y);
    icon.SetPosEx(refresh);
#endif
    icon.InitEx(item, refresh);
    return icon;
  }
 
  Icon InitIcon(Icon icon, EntityAI item, int pos_x, int pos_y)
  {
    return InitIconEx(icon, item, pos_x, pos_y);
  }
 
  bool HasItem(EntityAI item)
  {
    return m_ShowedItemPositions.Contains(item);
  }
 
  override bool TransferItemToVicinity()
  {
    if (CanDrop())
    {
      Man player = GetGame().GetPlayer();
      if (GetFocusedIcon())
      {
        ItemBase item = ItemBase.Cast(GetFocusedIcon().GetObject());
        if (item && player.CanDropEntity(item))
        {
          if (item.GetTargetQuantityMax() < item.GetQuantity())
            item.SplitIntoStackMaxClient(null, -1);
          else
            player.PhysicalPredictiveDropItem(item);
          return true;
        }
      }
    }
    return false;
  }
 
  override void SetDefaultFocus(bool while_micromanagment_mode = false)
  {
    super.SetDefaultFocus(while_micromanagment_mode);
 
    Unfocus();
    m_FocusedItemPosition = 0;
    UpdateSelection();
  }
 
  override void SetLastFocus()
  {
    SetDefaultFocus();
  }
 
  override void Unfocus()
  {
    Icon icon = GetFocusedIcon();
    if (icon)
      icon.SetActive(false);
  }
 
  override void UnfocusAll()
  {
    if (m_Icons)
    {
      foreach (Icon icon : m_Icons)
        icon.SetActive(false);
    }
    m_FocusedItemPosition = 0;
  }
 
  override void SetNextActive()
  {
    Unfocus();
    int focused_row = m_FocusedItemPosition / ROWS_NUMBER_XBOX;
    int max_row = (m_Icons.Count() - 1) / ROWS_NUMBER_XBOX;
 
    if (max_row > focused_row)
    {
      m_FocusedItemPosition += ROWS_NUMBER_XBOX;
      if (m_FocusedItemPosition >= m_Icons.Count())
        m_FocusedItemPosition = m_Icons.Count() - 1;
      UpdateSelection();
    }
    else
      SetActive(false);
  }
 
  override void SetPreviousActive(bool force = false)
  {
    Unfocus();
    int focused_row = m_FocusedItemPosition / ROWS_NUMBER_XBOX;
 
    if (focused_row > 0)
    {
      m_FocusedItemPosition = m_FocusedItemPosition - ROWS_NUMBER_XBOX;
      UpdateSelection();
    }
    else
      SetActive(false);
  }
 
 
  override void SetNextRightActive()
  {
    if (m_Icons.Count() > 0)
    {
      Unfocus();
      int focused_row = m_FocusedItemPosition / ROWS_NUMBER_XBOX;
      int row_min = focused_row * ROWS_NUMBER_XBOX;
      int row_max = row_min + ROWS_NUMBER_XBOX - 1;
 
      if (row_max >= m_Icons.Count())
        row_max = m_Icons.Count() - 1;
 
      m_FocusedItemPosition++;
      if (m_FocusedItemPosition > row_max)
        m_FocusedItemPosition = row_min;
 
      UpdateSelection();
    }
  }
 
  override void SetNextLeftActive()
  {
    if (m_Icons.Count() > 0)
    {
      Unfocus();
      int focused_row = m_FocusedItemPosition / ROWS_NUMBER_XBOX;
      int row_min = focused_row * ROWS_NUMBER_XBOX;
      int row_max = row_min + ROWS_NUMBER_XBOX - 1;
 
      if (row_max >= m_Icons.Count())
        row_max = m_Icons.Count() - 1;
 
      m_FocusedItemPosition--;
      if (m_FocusedItemPosition < row_min)
        m_FocusedItemPosition = row_max;
 
      UpdateSelection();
    }
  }
 
  override EntityAI GetFocusedItem()
  {
    Icon icon = GetFocusedIcon();
    if (icon)
      return EntityAI.Cast(icon.GetObject());
 
    return null;
  }
 
  override void SetLastActive()
  {
    super.SetLastActive();
    if (GetFocusedIcon())
      GetFocusedIcon().SetActive(false);
    m_FocusedItemPosition = ((m_Rows.Count() - 1) * ROWS_NUMBER_XBOX);
    UpdateSelection();
  }
 
  override void SetActive(bool active)
  {
    super.SetActive(active);
    UpdateSelection();
  }
 
  override bool IsItemActive()
  {
    if (GetFocusedIcon())
    {
      ItemBase item = ItemBase.Cast(GetFocusedIcon().GetObject());
      return (item != null);
    }
    return false;
  }
 
  override bool IsItemWithQuantityActive()
  {
    if (GetFocusedIcon())
    {
      ItemBase item = ItemBase.Cast(GetFocusedIcon().GetObject());
      return (!IsEmpty() && QuantityConversions.HasItemQuantity(item) && item.CanBeSplit());
    }
    return false;
  }
 
  override bool IsEmpty()
  {
    return m_Icons.Count() == 0;
  }
 
  int GetRecipeCount(bool recipe_anywhere, ItemBase entity1, ItemBase entity2, PlayerBase player)
  {
    PluginRecipesManager recipes_manager = PluginRecipesManager.Cast(GetPlugin(PluginRecipesManager));
    return recipes_manager.GetValidRecipes(entity1, entity2, null, player);
  }
 
  override bool CanCombineAmmo()
  {
    if (GetFocusedIcon())
    {
      ActionManagerClient amc = ActionManagerClient.Cast(PlayerBase.Cast(GetGame().GetPlayer()).GetActionManager());
 
      ItemBase entity = ItemBase.Cast(GetFocusedIcon().GetObject());
      ItemBase item_in_hands = ItemBase.Cast(GetGame().GetPlayer().GetHumanInventory().GetEntityInHands());
 
      return (amc.CanPerformActionFromInventory(item_in_hands, entity) || amc.CanSetActionFromInventory(item_in_hands, entity));
    }
    return false;
  }
 
  override bool TransferItem()
  {
    if (CanTakeToInventory())
    {
      if (GetFocusedIcon())
      {
        EntityAI entity = EntityAI.Cast(GetFocusedIcon().GetObject());
        if (entity)
        {
          GetGame().GetPlayer().PredictiveTakeEntityToInventory(FindInventoryLocationType.CARGO, entity);
          return true;
        }
      }
    }
    return false;
  }
 
  override bool SplitItem()
  {
    if (CanSplit())
    {
      if (GetFocusedIcon())
      {
        ItemBase entity = ItemBase.Cast(GetFocusedIcon().GetObject());
        if (entity)
        {
          if (entity.HasQuantity() && entity.CanBeSplit())
          {
            entity.OnRightClick();
            Icon icon = m_ShowedItemPositions.Get(entity).param1;
 
            if (icon)
              icon.SetQuantity();
          }
        }
      }
    }
    return false;
  }
 
  override bool EquipItem()
  {
    if (CanEquip())
    {
      if (GetFocusedIcon())
      {
        ItemBase entity = ItemBase.Cast(GetFocusedIcon().GetObject());
        if (entity)
        {
          GetGame().GetPlayer().PredictiveTakeEntityToInventory(FindInventoryLocationType.ATTACHMENT, entity);
          return true;
        }
      }
    }
    return false;
  }
 
  override bool SelectItem()
  {
    Icon focused_item = GetFocusedIcon();
    if (focused_item)
    {
      ItemBase item = ItemBase.Cast(focused_item.GetObject());
      if (item && item.IsTakeable() && item.CanPutIntoHands(null))
      {
        ItemManager.GetInstance().SetSelectedItemEx(item, this, focused_item);
        return true;
      }
    }
    return false;
  }
 
  override bool Select()
  {
    EntityAI focused_item = GetFocusedItem();
    EntityAI selected_item = ItemManager.GetInstance().GetSelectedItem();
    DayZPlayer player = GetGame().GetPlayer();
 
 
    if (focused_item != selected_item)
    {
      if (selected_item)
      {
        if (selected_item.GetInventory().CanRemoveEntity() && m_Entity)
        {
          bool can_add = m_Entity.GetInventory().CanAddEntityInCargo(selected_item, selected_item.GetInventory().GetFlipCargo());
          bool in_cargo = !player.GetInventory().HasEntityInInventory(selected_item) || !m_Entity.GetInventory().HasEntityInCargo(selected_item);
          if (can_add && in_cargo)
          {
            player.PredictiveTakeEntityToTargetCargo(m_Entity, selected_item);
            Container selected_cont2 = ItemManager.GetInstance().GetSelectedContainer();
            if (selected_cont2)
              selected_cont2.SetActive(false);
 
            SetActive(true);
            m_FocusedItemPosition = 0;
            return true;
          }
          else
          {
            Container selected_cont = ItemManager.GetInstance().GetSelectedContainer();
            if (selected_cont)
              selected_cont.SetActive(false);
 
            SetActive(true);
            SetDefaultFocus(true);
          }
        }
      }
      else if (focused_item && focused_item.GetInventory().CanRemoveEntity())
      {
        EntityAI item_in_hands = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
        if (item_in_hands)
        {
          if (GameInventory.CanSwapEntitiesEx(item_in_hands, focused_item))
          {
            player.PredictiveSwapEntities(item_in_hands, focused_item);
            return true;
          }
        }
        else
        {
          if (player.GetHumanInventory().CanAddEntityInHands(focused_item))
          {
            player.PredictiveTakeEntityToHands(focused_item);
            return true;
          }
        }
      }
    }
    return false;
  }
 
  override bool Combine()
  {
    if (CanCombine())
    {
      if (GetFocusedIcon())
      {
        Icon icon = GetFocusedIcon();
        if (icon)
        {
          EntityAI item_in_hands = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
          EntityAI prev_item = EntityAI.Cast(icon.GetObject());
          if (item_in_hands && prev_item)
            return icon.CombineItems(item_in_hands, prev_item);
        }
      }
    }
    return false;
  }
 
  void ShowFalseCargoHeader(bool show)
  {
    m_CargoHeader.Show(show);
  }
 
  void SetAlternateFalseTextHeaderWidget(TextWidget w)
  {
    bool update = !m_AlternateFalseHeaderTextWidget;
    m_AlternateFalseHeaderTextWidget = w;
    if (update)
      UpdateHeaderText();
  }
}