PlayerContainer.c

Go to the documentation of this file.

class PlayerContainer: CollapsibleContainer
{
  protected ref AttachmentsGroupContainer m_PlayerAttachmentsContainer;
  protected ref map<int, SlotsIcon> m_InventorySlots;
  protected ref map<EntityAI, ref Container> m_ShowedItems = new ref map<EntityAI, ref Container>;
  protected ref map<int, ref Container> m_ShowedItemsIDs = new ref map<int, ref Container>;
  protected PlayerBase m_Player;
 
  protected const int HEADER_INDEX_OFFSET = 2;
 
  override void UpdateRadialIcon()
  {
    if (m_SlotIcon)
    {
      bool show_radial_icon;
      show_radial_icon = IsHidden();
      Widget rip = m_SlotIcon.GetRadialIconPanel();
      rip.Show(!m_Player.GetInventory().IsInventoryLockedForLockType(HIDE_INV_FROM_SCRIPT) && m_Player.CanDisplayCargo());
      SetOpenForSlotIcon(show_radial_icon);
    }
  }
 
  bool HasEntityContainerVisible(EntityAI entity)
  {
    ClosableContainer cont = ClosableContainer.Cast(m_ShowedItems.Get(entity));
    return (cont && cont.IsOpened());
  }
 
  SlotsIcon GetSlotsIcon(int row, int column)
  {
    return m_PlayerAttachmentsContainer.GetSlotsIcon(row, column);
  }
 
  void PlayerContainer(LayoutHolder parent, int sort = -1)
  {
    m_InventorySlots = new ref map<int, SlotsIcon>;
    m_PlayerAttachmentsContainer = new AttachmentsGroupContainer(this);
 
    m_PlayerAttachmentsContainer.SetHeader(GetHeader());
    m_CollapsibleHeader.SetName("#container_inventory");
    SetHeader(null);
    m_Body.Insert(m_PlayerAttachmentsContainer);
    m_MainWidget = m_RootWidget.FindAnyWidget("body");
    m_PlayerAttachmentsContainer.GetRootWidget().SetColor(166 << 24 | 80 << 16 | 80 << 8 | 80);
    WidgetEventHandler.GetInstance().RegisterOnChildAdd(m_MainWidget, this, "OnChildAdd");
    WidgetEventHandler.GetInstance().RegisterOnChildRemove(m_MainWidget, this, "OnChildRemove");
 
    //START - InitGhostSlots
    string config_path_ghosts_slots = "CfgVehicles SurvivorBase InventoryEquipment playerSlots";
    ref array<string> player_ghosts_slots = new array<string>;
    GetGame().ConfigGetTextArray(config_path_ghosts_slots, player_ghosts_slots);
 
    for (int i = 0; i < player_ghosts_slots.Count(); i++)
    {
      string slot_name = player_ghosts_slots.Get(i);
      string path = "CfgSlots" + " " + slot_name;
 
      if (GetGame().ConfigIsExisting(path))
      {
        string icon_name; //icon_name must be in format "set:<setname> image:<imagename>"
        GetGame().ConfigGetText(path + " ghostIcon", icon_name);
        int slot_number = i;
        int column = slot_number % ITEMS_IN_ROW;
 
        //START - GetWidgetSlot
        int row = slot_number / ITEMS_IN_ROW;
        if (row >= m_PlayerAttachmentsContainer.Count())
        {
          if (row < (player_ghosts_slots.Count() / ITEMS_IN_ROW))
            AddSlotsContainer(ITEMS_IN_ROW);
          else
            AddSlotsContainer(player_ghosts_slots.Count() % ITEMS_IN_ROW);
        }
 
        SlotsIcon icon = GetSlotsIcon(row, column);
 
        icon.GetMainWidget().Show(true);
        icon.Clear();
 
        WidgetEventHandler.GetInstance().RegisterOnDoubleClick(icon.GetPanelWidget(), this, "DoubleClick");
 
        //END - GetWidgetSlot
        WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetPanelWidget(), this, "OnDropReceivedFromGhostArea");
        WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetGhostSlot(), this, "OnDropReceivedFromGhostArea");
        WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetGhostSlot(), this, "DraggingOver");
        WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetPanelWidget(), this, "DraggingOver");
        WidgetEventHandler.GetInstance().RegisterOnMouseButtonDown(icon.GetPanelWidget(), this, "MouseClick");
 
        icon.GetGhostSlot().LoadImageFile(0, StaticGUIUtils.VerifyIconImageString(StaticGUIUtils.IMAGESETGROUP_INVENTORY, icon_name));
        //END - LoadIconIntoWidgetSlot
 
        GetGame().ConfigGetText(path + " name", slot_name);
        int slot_id = InventorySlots.GetSlotIdFromString(slot_name);
        icon.SetSlotID(slot_id);
        icon.SetSlotDisplayName(InventorySlots.GetSlotDisplayName(slot_id));
        m_InventorySlots.Set(slot_id, icon);
      }
    }
    m_PlayerAttachmentsContainer.GetMainWidget().Update();
    //END - InitGhostSlots
    RecomputeOpenedContainers();
  }
 
  void ~PlayerContainer()
  {
    if (m_Player)
    {
      m_Player.GetOnItemAttached().Remove(ItemAttached);
      m_Player.GetOnItemDetached().Remove(ItemDetached);
      m_Player.GetOnAttachmentSetLock().Remove(OnAttachmentReservationSet);
      m_Player.GetOnAttachmentReleaseLock().Remove(OnAttachmentReservationRelease);
    }
  }
 
  void ItemAttached(EntityAI item, string slot_name)
  {
    int slot = InventorySlots.GetSlotIdFromString(slot_name);
    SlotsIcon icon = m_InventorySlots.Get(slot);
 
    if (icon)
    {
      if (icon.IsReserved())
        m_Player.GetOnAttachmentReleaseLock().Invoke(item, slot);
 
      icon.Init(item);
 
      if (m_ShowedItems.Contains(item) == false)
      {
        string name;
        int sort_index = Inventory.GetPlayerAttachmentIndex(slot);
        int current_sort = 9999;
        if (GetFocusedContainer())
          current_sort = GetFocusedContainer().GetRootWidget().GetSort();
 
        if (item.GetSlotsCountCorrect() > 0)
        {
          ContainerWithCargoAndAttachments iwca = new ContainerWithCargoAndAttachments(this, sort_index);
          iwca.SetEntity(item);
          iwca.SetSlotIcon(icon);
          WidgetEventHandler.GetInstance().RegisterOnMouseButtonUp(icon.GetPanelWidget(), this, "ToggleWidget");
 
          if (iwca.IsDisplayable())
            icon.GetRadialIconPanel().Show(true);
          m_ShowedItems.Insert(item, iwca);
          RecomputeOpenedContainers();
          Refresh();
        }
        else if (item.GetInventory().GetCargo())
        {
          ContainerWithCargo iwc = new ContainerWithCargo(this, sort_index);
          iwc.SetEntity(item);
          iwc.SetSlotIcon(icon);
          iwc.UpdateInterval();
          WidgetEventHandler.GetInstance().RegisterOnMouseButtonUp(icon.GetPanelWidget(), this, "ToggleWidget");
          m_ShowedItems.Insert(item, iwc);
          RecomputeOpenedContainers();
          if (iwc.IsDisplayable())
            icon.GetRadialIconPanel().Show(true);
 
          Refresh();
        }
      }
 
      ClosableContainer conta = ClosableContainer.Cast(m_ShowedItems.Get(item));
      string config = "CfgVehicles " + item.GetType() + " GUIInventoryAttachmentsProps";
      if (conta && conta.IsInherited(ClosableContainer))
      {
        bool show_radial_icon = (item.GetInventory().GetCargo() || item.GetSlotsCountCorrect() > 0) && !GetGame().ConfigIsExisting(config);
        Widget rip = icon.GetRadialIconPanel();
 
        rip.Show(show_radial_icon);
        SetOpenForSlotIcon(conta.IsOpened(), icon);
      }
    }
    UpdateSelectionIcons();
  }
 
  void ItemDetached(EntityAI item, string slot_name)
  {
    int slot = InventorySlots.GetSlotIdFromString(slot_name);
    SlotsIcon icon = m_InventorySlots.Get(slot);
 
    if (icon)
    {
      Container con = m_ShowedItems.Get(item);
      if (con)
      {
        (Container.Cast(con.m_Parent)).Remove(con);
        RecomputeOpenedContainers();
        GetMainWidget().Update();
        Refresh();
        m_ShowedItems.Remove(item);
      }
 
      icon.Clear();
      Inventory in = Inventory.Cast(GetRoot());
      if (in)
        in.UpdateConsoleToolbar();
    }
    UpdateSelectionIcons();
  }
 
  void OnAttachmentReservationSet(EntityAI item, int slot_id)
  {
    SlotsIcon icon = m_InventorySlots.Get(slot_id);
 
    if (item)
      icon.Init(item, true);
  }
 
  void OnAttachmentReservationRelease(EntityAI item, int slot_id)
  {
    SlotsIcon icon = m_InventorySlots.Get(slot_id);
    icon.Clear();
  }
 
  void AddSlotsContainer(int row_count)
  {
    SlotsContainer container = new SlotsContainer(m_PlayerAttachmentsContainer, m_Player);
    container.SetColumnCount(row_count);
    m_PlayerAttachmentsContainer.Insert(container);
  }
 
  void MouseClick(Widget w, int x, int y, int button)
  {
    SlotsIcon icon;
    w.GetUserData(icon);
 
    ItemBase selectedItem;
    bool isReserved;
 
    if (icon)
    {
      selectedItem = ItemBase.Cast(icon.GetEntity());
      isReserved = icon.IsReserved();
 
    }
 
    if (selectedItem)
    {
      switch (button)
      {
      case MouseState.RIGHT:
#ifdef DIAG_DEVELOPER
        if (GetDayZGame().IsLeftCtrlDown())
          ShowActionMenu(selectedItem);
#endif
 
        if (isReserved)
        {
          GetGame().GetPlayer().GetHumanInventory().ClearUserReservedLocationSynced(selectedItem);
          m_Player.GetOnAttachmentReleaseLock().Invoke(selectedItem, icon.GetSlotID());
        }
        break;
 
      case MouseState.MIDDLE:
        if (!isReserved)
          InspectItem(selectedItem);
 
        break;
 
      case MouseState.LEFT:
        if (!isReserved)
        {
          PlayerBase controlledPlayer = PlayerBase.Cast(GetGame().GetPlayer());
          if (g_Game.IsLeftCtrlDown())
          {
            if (controlledPlayer.CanDropEntity(selectedItem))
            {
              if (selectedItem.GetTargetQuantityMax() < selectedItem.GetQuantity())
                selectedItem.SplitIntoStackMaxClient(null, -1);
              else
                controlledPlayer.PhysicalPredictiveDropItem(selectedItem);
            }
          }
          else
          {
            bool draggable = !m_Player.GetInventory().HasInventoryReservation(selectedItem, null) && !m_Player.GetInventory().IsInventoryLocked() && selectedItem.GetInventory().CanRemoveEntity() && !m_Player.IsItemsToDelete();
            ItemManager.GetInstance().SetWidgetDraggable(w, draggable);
          }
        }
        break;
      }
    }
  }
 
  float GetMainContainerTopPos()
  {
    float x, y;
    GetRootWidget().GetScreenPos(x, y);
    return y;
  }
 
  float GetMainContainerBottomPos()
  {
    float x, y;
    float x2, y2;
    GetRootWidget().GetScreenPos(x, y);
    GetRootWidget().GetScreenSize(x2, y2);
    y += y2;
    return y;
  }
 
  override void Insert(LayoutHolder container, int pos = -1, bool immedUpdate = true)
  {
    ClosableContainer c_cont = ClosableContainer.Cast(container);
    if (c_cont && m_Body.Count() > 1)
    {
      ClosableContainer prev = ClosableContainer.Cast(m_Body.Get(1));
      int index = 1;
      int curr_sort = c_cont.GetRootWidget().GetSort();
      while (prev)
      {
        int prev_sort = prev.GetRootWidget().GetSort();
        if (prev_sort > curr_sort)
          break;
 
        if (++index < m_Body.Count())
          prev = ClosableContainer.Cast(m_Body.Get(index));
        else
          break;
      }
 
      m_Body.InsertAt(container, index);
    }
    else
      m_Body.Insert(container);
 
    if (immedUpdate)
      RecomputeOpenedContainers();
  }
 
  bool IsItemWithContainerActive()
  {
    EntityAI ent = GetFocusedItem();
    return ent && (ent.GetInventory().GetCargo() || ent.GetSlotsCountCorrect() > 0);
  }
 
  override bool IsItemWithQuantityActive()
  {
    EntityAI ent = GetFocusedItem();
    return ent && QuantityConversions.HasItemQuantity(ent) && ent.CanBeSplit();
  }
 
  override bool IsItemActive()
  {
    EntityAI ent = GetFocusedItem();
    return ent && !IsItemWithQuantityActive() && !IsItemWithContainerActive();
  }
 
  bool IsEmptyItemActive()
  {
    EntityAI ent = GetFocusedItem();
    return ent == null;
  }
 
  void UnfocusPlayerAttachmentsContainer()
  {
    m_PlayerAttachmentsContainer.UnfocusAll();
  }
 
  void DoubleClick(Widget w, int x, int y, int button)
  {
    if (button == MouseState.LEFT && !g_Game.IsLeftCtrlDown())
    {
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
      if (w == null || m_Player.GetInventory().IsInventoryLocked())
        return;
      ItemPreviewWidget iw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
      if (!iw)
      {
        string name = w.GetName();
        name.Replace("PanelWidget", "Render");
        iw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
      }
      if (!iw)
        iw = ItemPreviewWidget.Cast(w);
 
      ItemBase item = ItemBase.Cast(iw.GetItem());
 
      if (!item)
        return;
 
      SlotsIcon icon;
      iw.GetUserData(icon);
 
      if (icon && icon.IsReserved())
        return;
 
      if (!item.GetInventory().CanRemoveEntity())
        return;
 
      if (player.GetInventory().HasEntityInInventory(item) && player.GetHumanInventory().CanAddEntityInHands(item))
        player.PredictiveTakeEntityToHands(item);
      else
      {
        if (player.GetInventory().CanAddEntityToInventory(item) && item.GetInventory().CanRemoveEntity())
        {
          if (item.GetTargetQuantityMax() < item.GetQuantity())
            item.SplitIntoStackMaxClient(player, -1);
          else
            player.PredictiveTakeEntityToInventory(FindInventoryLocationType.ANY, item);
        }
        else
        {
          if (item.GetTargetQuantityMax() < item.GetQuantity())
            item.SplitIntoStackMaxHandsClient(player);
          else
            player.PredictiveTakeEntityToHands(item);
        }
      }
      ToggleWidget(w);
      HideOwnedTooltip();
 
      InventoryMenu menu = InventoryMenu.Cast(GetGame().GetUIManager().FindMenu(MENU_INVENTORY));
      if (menu)
        menu.RefreshQuickbar();
    }
  }
 
  override void ExpandCollapseContainer()
  {
    if (m_PlayerAttachmentsContainer.IsActive())
      ToggleWidget(m_PlayerAttachmentsContainer.GetFocusedSlotsIcon().GetPanelWidget());
  }
 
  bool IsContainerWithCargoActive()
  {
    return GetFocusedContainer().IsInherited(ContainerWithCargo);
  }
 
  bool IsItemWithAttachmentsActive()
  {
    return GetFocusedContainer().IsInherited(ContainerWithCargoAndAttachments);
  }
 
  override bool TransferItemToVicinity()
  {
    if (CanDrop())
    {
      if (GetFocusedContainer().IsInherited(ContainerWithCargo) || GetFocusedContainer().IsInherited(ContainerWithCargoAndAttachments))
        return GetFocusedContainer().TransferItemToVicinity();
      else
      {
        Man player = GetGame().GetPlayer();
        ItemBase item = ItemBase.Cast(GetFocusedItem());
        if (item && player.CanDropEntity(item))
        {
          if (item.GetTargetQuantityMax() < item.GetQuantity())
            item.SplitIntoStackMaxClient(null, -1);
          else
            player.PhysicalPredictiveDropItem(item);
          return true;
        }
      }
    }
    return false;
  }
 
  override bool InspectItem()
  {
    if (GetFocusedContainer().IsInherited(ContainerWithCargo) || GetFocusedContainer().IsInherited(ContainerWithCargoAndAttachments))
      return GetFocusedContainer().InspectItem();
    else
    {
      Man player = GetGame().GetPlayer();
      EntityAI item = GetFocusedItem();
      if (item)
      {
        InspectItem(item);
        return true;
      }
    }
    return false;
  }
 
  int GetRecipeCount(bool recipe_anywhere, EntityAI entity1, EntityAI entity2)
  {
    PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(GetPlugin(PluginRecipesManager));
    return plugin_recipes_manager.GetValidRecipes(ItemBase.Cast(entity1), ItemBase.Cast(entity2), null, PlayerBase.Cast(GetGame().GetPlayer()));
  }
 
  override bool SplitItem()
  {
    if (CanSplit())
    {
      if (GetFocusedContainer().IsInherited(ContainerWithCargo) || GetFocusedContainer().IsInherited(ContainerWithCargoAndAttachments))
        return GetFocusedContainer().SplitItem();
    }
 
    return false;
  }
 
  override bool EquipItem()
  {
    if (CanEquip())
    {
      if (GetFocusedContainer().IsInherited(ContainerWithCargo) || GetFocusedContainer().IsInherited(ContainerWithCargoAndAttachments))
        return GetFocusedContainer().EquipItem();
      else
      {
        EntityAI item = GetFocusedItem();
        if (item)
        {
          GetGame().GetPlayer().PredictiveTakeEntityToInventory(FindInventoryLocationType.ATTACHMENT, item);
          return true;
        }
      }
    }
    return false;
  }
 
  override bool TransferItem()
  {
    if (CanTakeToInventory())
    {
      LeftArea left_area = LeftArea.Cast(GetParent());
      EntityAI item;
      if (left_area)
      {
        if (GetFocusedContainer().IsInherited(ContainerWithCargo) || GetFocusedContainer().IsInherited(ContainerWithCargoAndAttachments))
          return GetFocusedContainer().TransferItem();
        else
        {
          item = GetFocusedItem();
          if (item)
          {
            GetGame().GetPlayer().PredictiveTakeEntityToInventory(FindInventoryLocationType.CARGO, item);
            return true;
          }
        }
      }
      else
      {
        if (!GetFocusedContainer().IsInherited(ContainerWithCargo) && !GetFocusedContainer().IsInherited(ContainerWithCargoAndAttachments))
        {
          item = GetFocusedItem();
          if (item)
          {
            GetGame().GetPlayer().PredictiveTakeEntityToInventory(FindInventoryLocationType.CARGO, item);
            return true;
          }
        }
      }
    }
    return false;
  }
 
  override EntityAI GetFocusedItem()
  {
    return GetFocusedContainer().GetFocusedItem();
  }
 
  override bool Combine()
  {
    if (CanCombine())
    {
      if (GetFocusedContainer() && (GetFocusedContainer().IsInherited(ContainerWithCargo) || GetFocusedContainer().IsInherited(ContainerWithCargoAndAttachments)))
        return GetFocusedContainer().Combine();
      else
      {
        EntityAI item = GetFocusedItem();
        ItemBase item_in_hands = ItemBase.Cast(GetGame().GetPlayer().GetHumanInventory().GetEntityInHands());
 
        Icon hands_icon = ItemManager.GetInstance().GetHandsPreview().GetIcon();
 
        if (item_in_hands && item)
          return hands_icon.CombineItems(item_in_hands, item);
      }
    }
    return true;
  }
 
  override bool Select()
  {
    if (GetFocusedContainer().IsInherited(ContainerWithCargo) || GetFocusedContainer().IsInherited(ContainerWithCargoAndAttachments))
      return GetFocusedContainer().Select();
    else
    {
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
      EntityAI selected_item = ItemManager.GetInstance().GetSelectedItem();
      SlotsIcon focused_slot = GetFocusedSlotsIcon();
      EntityAI focused_item = focused_slot.GetEntity();
      if (focused_slot.IsReserved() || focused_item != selected_item)
      {
        if (selected_item)
        {
          if (selected_item.GetInventory().CanRemoveEntity())
          {
            if (m_Player.GetInventory().CanAddAttachmentEx(selected_item, focused_slot.GetSlotID()))
            {
              player.PredictiveTakeEntityToTargetAttachmentEx(m_Player, selected_item, focused_slot.GetSlotID());
              //m_Player.PredictiveTakeEntityAsAttachmentEx( selected_item, focused_slot.GetSlotID() );
              ItemManager.GetInstance().SetSelectedItemEx(null, null, null);
              return true;
 
            }
            else if (m_Player.GetInventory().CanAddAttachment(selected_item))
            {
              player.PredictiveTakeEntityToTargetAttachment(m_Player, selected_item);
              //m_Player.PredictiveTakeEntityToInventory( FindInventoryLocationType.ATTACHMENT, selected_item );
              ItemManager.GetInstance().SetSelectedItemEx(null, null, null);
              return true;
            }
          }
        }
        else
        {
          if (focused_item && focused_item.GetInventory().CanRemoveEntity())
          {
            EntityAI item_in_hands = player.GetHumanInventory().GetEntityInHands();
            if (item_in_hands && item_in_hands.GetInventory().CanRemoveEntity())
            {
              if (GameInventory.CanSwapEntitiesEx(item_in_hands, focused_item))
              {
                player.PredictiveSwapEntities(item_in_hands, focused_item);
                return true;
              }
              else
              {
                InventoryLocation il_hands_dst = new InventoryLocation;
                if (player.GetHumanInventory().FindFreeLocationFor(item_in_hands, FindInventoryLocationType.ANY, il_hands_dst))
                {
                  InventoryMode invMode = InventoryMode.PREDICTIVE;
 
                  if (player.NeedInventoryJunctureFromServer(item_in_hands, item_in_hands.GetHierarchyParent(), il_hands_dst.GetParent()) || GetGame().GetPlayer().NeedInventoryJunctureFromServer(focused_item, focused_item.GetHierarchyParent(), GetGame().GetPlayer()))
                    invMode = InventoryMode.JUNCTURE;
 
                  player.GetHumanInventory().ForceSwapEntities(invMode, focused_item, item_in_hands, il_hands_dst);
                  return true;
                }
              }
            }
            else
            {
              if (player.GetHumanInventory().CanAddEntityInHands(focused_item))
              {
                player.PredictiveTakeEntityToHands(focused_item);
                return true;
              }
            }
          }
        }
      }
    }
    return false;
  }
 
  void SetPlayer(PlayerBase player)
  {
    if (m_Player)
    {
      m_Player.GetOnItemAttached().Remove(ItemAttached);
      m_Player.GetOnItemDetached().Remove(ItemDetached);
      m_Player.GetOnAttachmentSetLock().Remove(OnAttachmentReservationSet);
      m_Player.GetOnAttachmentReleaseLock().Remove(OnAttachmentReservationRelease);
    }
 
    m_Player = player;
    if (m_Player)
    {
      m_Player.GetOnItemAttached().Insert(ItemAttached);
      m_Player.GetOnItemDetached().Insert(ItemDetached);
      m_Player.GetOnAttachmentSetLock().Insert(OnAttachmentReservationSet);
      m_Player.GetOnAttachmentReleaseLock().Insert(OnAttachmentReservationRelease);
    }
 
    //START - InitGhostSlots
    string config_path_ghosts_slots = "CfgVehicles SurvivorBase InventoryEquipment playerSlots";
    ref array<string> player_ghosts_slots = new array<string>;
    GetGame().ConfigGetTextArray(config_path_ghosts_slots, player_ghosts_slots);
 
    for (int i = 0; i < player_ghosts_slots.Count(); i++)
    {
      string slot_name = player_ghosts_slots.Get(i);
 
      int column = i % ITEMS_IN_ROW;
      int row = i / ITEMS_IN_ROW;
 
      SlotsIcon icon = GetSlotsIcon(row, column);
 
      icon.SetSlotParent(m_Player);
      icon.GetMainWidget().Show(true);
      icon.Clear();
 
      GetGame().ConfigGetText("CfgSlots" + " " + slot_name + " name", slot_name);
      EntityAI item = m_Player.GetInventory().FindAttachment(InventorySlots.GetSlotIdFromString(slot_name));
      if (item)
        ItemAttached(item, slot_name);
    }
  }
 
  override void OnDropReceivedFromHeader(Widget w, int x, int y, Widget receiver)
  {
    ItemPreviewWidget ipw = ItemPreviewWidget.Cast(GetItemPreviewWidget(w));
 
    if (!ipw.IsInherited(ItemPreviewWidget))
      return;
 
    EntityAI item = ipw.GetItem();
    if (!item)
      return;
 
    if (!item.GetInventory().CanRemoveEntity())
      return;
 
    if (m_Player.GetInventory().CanAddEntityToInventory(item, FindInventoryLocationType.CARGO | FindInventoryLocationType.ATTACHMENT) && (!m_Player.GetInventory().HasEntityInInventory(item)))
      m_Player.PredictiveTakeEntityToInventory(FindInventoryLocationType.CARGO | FindInventoryLocationType.ATTACHMENT, item);
  }
 
  ItemPreviewWidget GetItemPreviewWidget(Widget w)
  {
    ItemPreviewWidget ipw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
    if (!ipw)
    {
      string name = w.GetName();
      name.Replace("PanelWidget", "Render");
      ipw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
    }
    if (!ipw)
      ipw = ItemPreviewWidget.Cast(w);
 
    return ipw;
  }
 
  override void DraggingOverHeader(Widget w, int x, int y, Widget receiver)
  {
    if (w == null)
      return;
    ItemPreviewWidget ipw = GetItemPreviewWidget(w);
 
    if (!ipw || !ipw.IsInherited(ItemPreviewWidget))
      return;
 
    EntityAI item = ipw.GetItem();
    if (!item)
      return;
 
    if (m_Player.GetInventory().CanAddEntityToInventory(item, FindInventoryLocationType.CARGO | FindInventoryLocationType.ATTACHMENT) && !m_Player.GetInventory().HasEntityInInventory(item))
    {
      ItemManager.GetInstance().HideDropzones();
      ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
      ColorManager.GetInstance().SetColor(w, ColorManager.GREEN_COLOR);
    }
    else
    {
      ItemManager.GetInstance().HideDropzones();
      ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
      ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
      //ItemManager.GetInstance().ShowSourceDropzone( item );
    }
  }
 
  override void DraggingOver(Widget w, int x, int y, Widget receiver)
  {
    if (w == null)
      return;
 
    EntityAI receiver_item;
    bool is_reserved = false;
 
    SlotsIcon slots_icon;
    receiver.GetUserData(slots_icon);
 
    if (slots_icon)
    {
      receiver_item = slots_icon.GetEntity();
      is_reserved = slots_icon.IsReserved();
    }
 
    ItemPreviewWidget ipw = ItemPreviewWidget.Cast(GetItemPreviewWidget(w));
 
    if (!ipw || !ipw.IsInherited(ItemPreviewWidget))
      return;
 
    EntityAI item = ipw.GetItem();
    if (!item)
      return;
 
    if (receiver_item && !is_reserved)
    {
      if (GameInventory.CanSwapEntitiesEx(receiver_item, item))
      {
        ColorManager.GetInstance().SetColor(w, ColorManager.SWAP_COLOR);
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
        return;
      }
      else if (receiver_item.GetInventory().CanAddAttachment(item) || receiver_item.GetInventory().CanAddEntityInCargo(item, item.GetInventory().GetFlipCargo()) && !receiver_item.GetInventory().HasEntityInCargo(item))
      {
        ColorManager.GetInstance().SetColor(w, ColorManager.GREEN_COLOR);
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
        return;
      }
      else if ((ItemBase.Cast(receiver_item)).CanBeCombined(ItemBase.Cast(item)))
      {
        ColorManager.GetInstance().SetColor(w, ColorManager.COMBINE_COLOR);
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
        return;
      }
 
    }
 
    if (item.GetInventory().CanRemoveEntity())
    {
      if (m_Player.GetInventory().CanAddAttachment(item))
      {
        ColorManager.GetInstance().SetColor(w, ColorManager.GREEN_COLOR);
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
      }
      else if (m_Player.GetInventory().CanAddEntityToInventory(item, FindInventoryLocationType.CARGO | FindInventoryLocationType.ATTACHMENT) && (!m_Player.GetInventory().HasEntityInInventory(item)) || m_Player.GetHumanInventory().HasEntityInHands(item))
      {
        ColorManager.GetInstance().SetColor(w, ColorManager.GREEN_COLOR);
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
      }
      else if (receiver_item && GameInventory.CanSwapEntitiesEx(receiver_item, item))
      {
        ColorManager.GetInstance().SetColor(w, ColorManager.SWAP_COLOR);
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
      }
      else
      {
        ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
      }
    }
    else
    {
      ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
      ItemManager.GetInstance().HideDropzones();
      ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
      //ItemManager.GetInstance().ShowSourceDropzone( item );
    }
  }
 
  void OnDropReceivedFromGhostArea(Widget w, int x, int y, Widget receiver)
  {
    ItemManager.GetInstance().HideDropzones();
    ItemManager.GetInstance().SetIsDragging(false);
 
    EntityAI receiver_item;
    bool is_reserved = false;
    InventoryMenu menu = InventoryMenu.Cast(GetGame().GetUIManager().FindMenu(MENU_INVENTORY));
    float stack_max;
 
    ItemPreviewWidget ipw = ItemPreviewWidget.Cast(GetItemPreviewWidget(w));
    SlotsIcon slots_icon;
    receiver.GetUserData(slots_icon);
    int slot_id = slots_icon.GetSlotID();
 
    receiver_item = slots_icon.GetEntity();
    is_reserved = slots_icon.IsReserved();
    InventoryLocation il;
 
    if (!ipw)
      return;
 
    ItemBase item = ItemBase.Cast(ipw.GetItem());
    PlayerBase real_player = PlayerBase.Cast(GetGame().GetPlayer());
    if (!item)
      return;
    if (receiver_item && !is_reserved)
    {
      if (GameInventory.CanSwapEntitiesEx(receiver_item, item))
      {
        GetGame().GetPlayer().PredictiveSwapEntities(item, receiver_item);
 
        if (menu)
          menu.RefreshQuickbar();
        return;
      }
      else if (receiver_item.GetInventory().CanAddAttachment(item))
      {
        GetGame().GetPlayer().PredictiveTakeEntityToTargetAttachment(receiver_item, item);
 
        if (menu)
          menu.RefreshQuickbar();
        return;
      }
      else if (receiver_item.GetInventory().CanAddEntityInCargo(item, item.GetInventory().GetFlipCargo()) && !receiver_item.GetInventory().HasEntityInCargo(item))
      {
        SplitItemUtils.TakeOrSplitToInventory(real_player, receiver_item, item);
 
        if (menu)
          menu.RefreshQuickbar();
        return;
      }
      else if ((ItemBase.Cast(receiver_item)).CanBeCombined(ItemBase.Cast(item)))
      {
        (ItemBase.Cast(receiver_item)).CombineItemsClient(ItemBase.Cast(item));
        return;
      }
    }
 
    if (m_Player.GetInventory().CanAddAttachmentEx(item, slot_id))
    {
      if (item.GetQuantity() > item.GetTargetQuantityMax(slot_id))
        item.SplitIntoStackMaxClient(real_player, slot_id);
      else
        real_player.PredictiveTakeEntityToTargetAttachmentEx(m_Player, item, slots_icon.GetSlotID());
    }
    else if (m_Player.GetInventory().CanAddAttachment(item))
    {
      il = new InventoryLocation;
      m_Player.GetInventory().FindFreeLocationFor(item, FindInventoryLocationType.ATTACHMENT, il);
      float stackable = item.GetTargetQuantityMax(-1);
 
      if (il.IsValid())
      {
        if (stackable == 0 || stackable >= item.GetQuantity())
          real_player.PredictiveTakeEntityToTargetAttachment(il.GetParent(), item);
        else
 
          ItemBase.Cast(item).SplitIntoStackMaxToInventoryLocationClient(il);
      }
    }
    else if (m_Player.GetInventory().CanAddEntityToInventory(item, FindInventoryLocationType.CARGO | FindInventoryLocationType.ATTACHMENT) && (!m_Player.GetInventory().HasEntityInInventory(item)) || m_Player.GetHumanInventory().HasEntityInHands(item))
      SplitItemUtils.TakeOrSplitToInventory(m_Player, m_Player, item);
 
    if (menu)
      menu.RefreshQuickbar();
  }
 
  void SwapItemsInOrder(int slot1, int slot2)
  {
    EntityAI item1 = m_Player.GetInventory().FindAttachment(slot1);
    EntityAI item2 = m_Player.GetInventory().FindAttachment(slot2);
 
    if (item1 && item2)
    {
      Container cont1 = m_ShowedItems.Get(item1);
      Container cont2 = m_ShowedItems.Get(item2);
      if (cont1 && cont2)
      {
        int sort1 = cont1.GetRootWidget().GetSort();
        int sort2 = cont2.GetRootWidget().GetSort();
 
        cont1.GetRootWidget().SetSort(sort2);
        cont2.GetRootWidget().SetSort(sort1);
 
        m_Body.SwapItems(m_Body.Find(cont1), m_Body.Find(cont2));
      }
    }
    RecomputeOpenedContainers();
  }
 
  override void UpdateInterval()
  {
    int i;
    for (i = 0; i < m_InventorySlots.Count(); i++)
    {
      SlotsIcon icon = m_InventorySlots.GetElement(i);
      if (icon)
        icon.UpdateInterval();
    }
    for (i = 0; i < m_ShowedItems.Count(); i++)
    {
      Container cont = m_ShowedItems.GetElement(i);
      if (cont)
        cont.UpdateInterval();
    }
  }
 
  // Call from ToggleWidget
  void ToggleContainer(Widget w, EntityAI item)
  {
    InventoryLocation il = new InventoryLocation;
    item.GetInventory().GetCurrentInventoryLocation(il);
    SlotsIcon icon = m_InventorySlots.Get(il.GetSlot());
    ClosableContainer c = ClosableContainer.Cast(m_ShowedItems.Get(item));
    if (c)
    {
      c.Toggle();
      Refresh();
    }
  }
 
  override bool CanOpenCloseContainerEx(EntityAI focusedEntity)
  {
    if (focusedEntity)
    {
      ClosableContainer c = ClosableContainer.Cast(m_ShowedItems.Get(focusedEntity));
      if (c && c.IsDisplayable())
        return true;
    }
    return false;
  }
 
  // Mouse button UP or Call other fn
  void ToggleWidget(Widget w)
  {
    if (ItemManager.GetInstance().IsDragging())
      return;
    string name = w.GetName();
    name.Replace("PanelWidget", "Render");
    ItemPreviewWidget ipw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
    if (ipw.GetItem())
    {
      ToggleContainer(w, ipw.GetItem());
      RecomputeOpenedContainers();
    }
 
    Refresh();
  }
 
  override void CollapseButtonOnMouseButtonDown(Widget w)
  {
    super.CollapseButtonOnMouseButtonDown(w);
  }
 
  bool IsPlayerEquipmentActive()
  {
    if (GetFocusedContainer() && (GetFocusedContainer().IsInherited(ContainerWithCargo) || GetFocusedContainer().IsInherited(ContainerWithCargoAndAttachments)))
      return false;
 
    return true;
  }
 
  override void Refresh()
  {
    super.Refresh();
    m_MainWidget.Update();
    m_RootWidget.Update();
    UpdateSelectionIcons();
  }
 
  override bool OnChildRemove(Widget w, Widget child)
  {
    Refresh();
    return true;
  }
 
  override bool OnChildAdd(Widget w, Widget child)
  {
    Refresh();
    return true;
  }
}