AttachmentCategoriesRow.c

Go to the documentation of this file.

class AttachmentCategoriesRow: ClosableContainer
{
  protected string m_CategoryIdentifier;
  protected string m_RowConfigPath;
  protected bool m_Refreshing;
 
  protected ref AttachmentsGroupContainer m_AttachmentsContainer;
  protected ref map<int, ref ContainerWithCargo> m_AttachmentCargos;
 
  void AttachmentCategoriesRow(LayoutHolder parent, int sort = -1)
  {
    m_Refreshing = false;
    m_AttachmentCargos = new map<int, ref ContainerWithCargo>;
    m_AttachmentsContainer = new AttachmentsGroupContainer(this);
 
    m_Body.Insert(m_AttachmentsContainer);
 
    m_ClosableHeader.GetMainWidget().ClearFlags(WidgetFlags.DRAGGABLE);
 
    RecomputeOpenedContainers();
  }
 
  string GetCategoryIdentifier()
  {
    return m_CategoryIdentifier;
  }
 
  int GetFocusedSlot()
  {
    SlotsIcon icon = GetFocusedSlotsIcon();
    if (icon)
      return icon.GetSlotID();
    return -1;
  }
 
  override bool Select()
  {
    Man player = GetGame().GetPlayer();
    SlotsIcon focused_icon = GetFocusedSlotsIcon();
    EntityAI focused_item = GetFocusedItem();
    Container focused_cont = GetFocusedContainer();
    ItemBase selected_item = ItemBase.Cast(ItemManager.GetInstance().GetSelectedItem()); // == dragged item
 
    if (selected_item && focused_item != selected_item)//dropping from micromanagement
    {
      if (selected_item.GetInventory().CanRemoveEntity())
      {
        int stack_max;
 
        if (!focused_icon)
        {
          if (focused_cont)
            focused_cont.Select();
        }
        else if (!focused_item && m_Entity && m_Entity.GetInventory().CanAddAttachmentEx(selected_item, focused_icon.GetSlotID()))
        {
          stack_max = InventorySlots.GetStackMaxForSlotId(focused_icon.GetSlotID());
          float quantity = selected_item.GetQuantity();
          if (stack_max == 0 || stack_max >= quantity || !selected_item.CanBeSplit())
          {
            player.PredictiveTakeEntityToTargetAttachmentEx(m_Entity, selected_item, focused_icon.GetSlotID());
            return true;
          }
          else
          {
            selected_item.SplitIntoStackMaxClient(m_Entity, focused_icon.GetSlotID());
            return true;
          }
        }
        else if (focused_icon.GetSlotID() != -1)
        {
          if (focused_item && focused_item.GetHierarchyParent() && focused_item.GetHierarchyParent().GetInventory().CanAddAttachment(selected_item))
          {
            InventoryLocation inv_loc = new InventoryLocation;
            focused_item.GetInventory().GetCurrentInventoryLocation(inv_loc);
            stack_max = InventorySlots.GetStackMaxForSlotId(inv_loc.GetSlot());
            quantity = focused_item.GetQuantity();
            if (focused_item.CanBeCombined(ItemBase.Cast(selected_item)))
            {
              focused_item.CombineItemsClient(selected_item, true);
              return true;
            }
            else if (stack_max == 0 && GameInventory.CanSwapEntitiesEx(focused_item, selected_item))
            {
              player.PredictiveSwapEntities(selected_item, focused_item);
              return true;
            }
            else if (m_AttachmentCargos.Contains(inv_loc.GetSlot()))
            {
              if (focused_item.GetInventory().CanAddEntityInCargo(selected_item, selected_item.GetInventory().GetFlipCargo()))
              {
                SplitItemUtils.TakeOrSplitToInventory(PlayerBase.Cast(player), focused_item, selected_item);
                return true;
              }
            }
          }
        }
      }
    }
    else //clicking
    {
      if (focused_item && focused_item.GetInventory().CanRemoveEntity() && (!focused_icon || !focused_icon.IsOutOfReach()))
      {
        EntityAI item_in_hands = GetGame().GetPlayer().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
        {
          if (player.GetHumanInventory().CanAddEntityInHands(focused_item))
          {
            player.PredictiveTakeEntityToHands(focused_item);
            return true;
          }
        }
      }
    }
 
    return false;
  }
 
  override bool TransferItem()
  {
    if (CanTakeToInventory())
    {
      EntityAI entity = GetFocusedItem();
      SlotsIcon focused_icon = GetFocusedSlotsIcon();
      if (entity && !entity.IsLockedInSlot() && (!focused_icon || !focused_icon.IsOutOfReach()))
      {
        PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
        GetGame().GetPlayer().PredictiveTakeEntityToInventory(FindInventoryLocationType.CARGO, entity);
        return true;
      }
    }
    return false;
  }
 
  override bool TransferItemToVicinity()
  {
    if (CanDrop())
    {
      ItemBase item = ItemBase.Cast(GetFocusedItem());
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
      SlotsIcon focused_icon = GetFocusedSlotsIcon();
 
      if (item && !item.IsLockedInSlot() && (focused_icon && !focused_icon.IsOutOfReach()))
      {
        if (item.GetTargetQuantityMax() < item.GetQuantity())
          item.SplitIntoStackMaxClient(null, -1);
        else
          player.PhysicalPredictiveDropItem(item);
        return true;
      }
    }
    return false;
  }
 
  override bool Combine()
  {
    if (CanCombine())
    {
      Man player = GetGame().GetPlayer();
      ItemBase prev_item = ItemBase.Cast(GetFocusedItem());
      ItemBase selected_item = ItemBase.Cast(player.GetHumanInventory().GetEntityInHands());
      SlotsIcon focused_icon = GetFocusedSlotsIcon();
 
      if (selected_item)
      {
        int selected_slot = GetFocusedSlot();
        int stack_max;
        if (selected_item && selected_item.GetInventory().CanRemoveEntity() && (focused_icon && !focused_icon.IsOutOfReach()))
        {
          if (!prev_item && m_Entity.GetInventory().CanAddAttachmentEx(selected_item, selected_slot))
          {
            stack_max = InventorySlots.GetStackMaxForSlotId(selected_slot);
            float quantity = selected_item.GetQuantity();
            if (stack_max == 0 || stack_max >= quantity || !selected_item.CanBeSplit())
            {
              player.PredictiveTakeEntityToTargetAttachmentEx(m_Entity, selected_item, selected_slot);
              return true;
            }
            else
            {
              selected_item.SplitIntoStackMaxClient(m_Entity, selected_slot);
              return true;
            }
          }
          else if (selected_slot != -1)
          {
            if (prev_item)
            {
              InventoryLocation inv_loc = new InventoryLocation;
              prev_item.GetInventory().GetCurrentInventoryLocation(inv_loc);
              stack_max = InventorySlots.GetStackMaxForSlotId(inv_loc.GetSlot());
              quantity = prev_item.GetQuantity();
              if (prev_item.CanBeCombined(ItemBase.Cast(selected_item)))
              {
                prev_item.CombineItemsClient(selected_item, true);
                return true;
              }
              else if (stack_max == 0 && GameInventory.CanSwapEntitiesEx(prev_item, selected_item))
              {
                player.PredictiveSwapEntities(selected_item, prev_item);
                return true;
              }
              else if (m_AttachmentCargos.Contains(inv_loc.GetSlot()))
              {
                if (prev_item.GetInventory().CanAddEntityInCargo(selected_item, selected_item.GetInventory().GetFlipCargo()))
                {
                  SplitItemUtils.TakeOrSplitToInventory(PlayerBase.Cast(player), prev_item, selected_item);
                  return true;
                }
              }
            }
          }
        }
      }
    }
    return false;
  }
 
  override bool CanSplitEx(EntityAI focusedItem)
  {
    return false;
  }
 
  override bool SplitItem()
  {
    return false;
  }
 
  override bool EquipItem() //TODO: may be possible, but the hint doesn't reflect it anyway
  {
    return false;
  }
 
  override bool CanCombine()
  {
    Man player = GetGame().GetPlayer();
    ItemBase prev_item = ItemBase.Cast(GetFocusedItem());
    ItemBase selected_item = ItemBase.Cast(player.GetHumanInventory().GetEntityInHands());
    SlotsIcon focused_icon = GetFocusedSlotsIcon();
 
    if (selected_item)
    {
      int selected_slot = GetFocusedSlot();
      int stack_max;
      if (selected_item && selected_item.GetInventory().CanRemoveEntity() && (focused_icon && !focused_icon.IsOutOfReach()))
      {
        if (m_Entity.GetInventory().CanAddAttachmentEx(selected_item, selected_slot))
        {
          stack_max = InventorySlots.GetStackMaxForSlotId(selected_slot);
          float quantity = selected_item.GetQuantity();
          if (stack_max == 0 || stack_max >= quantity || !selected_item.CanBeSplit())
            return true;
          else
            return true;
        }
        else if (selected_slot != -1)
        {
          if (prev_item)
          {
            InventoryLocation inv_loc = new InventoryLocation;
            prev_item.GetInventory().GetCurrentInventoryLocation(inv_loc);
            stack_max = InventorySlots.GetStackMaxForSlotId(inv_loc.GetSlot());
            quantity = prev_item.GetQuantity();
            if (prev_item.CanBeCombined(ItemBase.Cast(selected_item)))
              return true;
          }
        }
      }
    }
    return false;
  }
 
  override bool CanCombineAmmo()
  {
    return false;
  }
 
  override bool IsItemActive()
  {
    SlotsIcon icon = GetFocusedSlotsIcon();
    return GetFocusedItem() != null && (!icon || !icon.IsOutOfReach());
  }
 
  override bool IsItemWithQuantityActive()
  {
    ItemBase item = ItemBase.Cast(GetFocusedItem());
    SlotsIcon icon = GetFocusedSlotsIcon();
    return item && (!icon || !icon.IsOutOfReach()) && item.CanBeSplit();
  }
 
  override void OnDropReceivedFromHeader(Widget w, int x, int y, Widget receiver)
  {
    ItemManager.GetInstance().HideDropzones();
    ItemManager.GetInstance().SetIsDragging(false);
    SlotsIcon slots_icon;
    EntityAI receiver_item;
    int slot_id = -1;
    bool is_reserved = false;
    EntityAI attached_entity;
    receiver.GetUserData(slots_icon);
    float stackable = 0.0;
    InventoryLocation il = new InventoryLocation;
 
    if (slots_icon)
    {
      receiver_item = slots_icon.GetEntity();
      slot_id = slots_icon.GetSlotID();
      attached_entity = slots_icon.GetSlotParent();
      is_reserved = slots_icon.IsReserved();
    }
 
    EntityAI item = GetItemPreviewItem(w);
    if (!item)
      return;
    ItemBase item_base = ItemBase.Cast(item);
 
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    if (!item.GetInventory().CanRemoveEntity() || !player.CanManipulateInventory())
      return;
 
    EntityAI target_att_entity = m_Entity;
    Weapon_Base wpn;
    Magazine mag;
    if (Class.CastTo(wpn, m_Entity) && Class.CastTo(mag, item))
    {
      if (player.GetWeaponManager().CanAttachMagazine(wpn, mag))
        player.GetWeaponManager().AttachMagazine(mag);
    }
    else if (receiver_item && !is_reserved)
    {
      if ((ItemBase.Cast(receiver_item)).CanBeCombined(ItemBase.Cast(item)))
        (ItemBase.Cast(receiver_item)).CombineItemsClient(ItemBase.Cast(item));
      else if (GameInventory.CanSwapEntitiesEx(receiver_item, item))
      {
        if (!receiver_item.GetInventory().CanRemoveEntity())
          return;
        GetGame().GetPlayer().PredictiveSwapEntities(receiver_item, item);
      }
      else if (receiver_item.GetInventory().CanAddAttachment(item))
        player.PredictiveTakeEntityToTargetAttachment(receiver_item, item);
    }
    else if (attached_entity && slot_id != -1 && attached_entity.GetInventory().CanAddAttachmentEx(item, slot_id))
    {
      item_base = ItemBase.Cast(item);
      stackable = item_base.GetTargetQuantityMax(slot_id);
 
      if (stackable == 0 || stackable >= item_base.GetQuantity())
        player.PredictiveTakeEntityToTargetAttachmentEx(attached_entity, item, slot_id);
      else if (stackable != 0 && stackable < item_base.GetQuantity())
        item_base.SplitIntoStackMaxClient(m_Entity, slot_id);
    }
    else if (attached_entity && slot_id == -1 && attached_entity.GetInventory().FindFreeLocationFor(item, FindInventoryLocationType.ATTACHMENT, il))
    {
      item_base = ItemBase.Cast(item);
      stackable = item_base.GetTargetQuantityMax(il.GetSlot());
 
      if (stackable == 0 || stackable >= item_base.GetQuantity())
        player.PredictiveTakeEntityToTargetAttachmentEx(attached_entity, item, il.GetSlot());
      else if (stackable != 0 && stackable < item_base.GetQuantity())
        item_base.SplitIntoStackMaxClient(m_Entity, il.GetSlot());
    }
    /*else if( ( m_Entity.GetInventory().CanAddEntityInCargo( item, item.GetInventory().GetFlipCargo() ) && ( !player.GetInventory().HasEntityInInventory( item ) || !m_Entity.GetInventory().HasEntityInCargo( item )) ) )
      {
      SplitItemUtils.TakeOrSplitToInventory( PlayerBase.Cast( GetGame().GetPlayer() ), m_Entity, item );
      }*/
  }
 
  override void UnfocusAll()
  {
    int i;
    for (i = 1; i < Count(); i++)
    {
      for (int j = 0; j < ITEMS_IN_ROW; j++)
      {
        Widget w = Get(i).GetMainWidget().FindAnyWidget("Cursor" + j);
        if (w)
          w.Show(false);
      }
    }
    for (i = 0; i < m_AttachmentCargos.Count(); i++)
    {
      m_AttachmentCargos.GetElement(i).Unfocus();
      m_AttachmentCargos.GetElement(i).SetActive(false);
    }
  }
 
  override void DraggingOverHeader(Widget w, int x, int y, Widget receiver)
  {
    if (w == null)
      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);
 
    if (!iw || !iw.GetItem() || (iw.GetItem() == m_Entity))
      return;
 
    ItemBase item;
    ItemBase receiver_item;
    name = receiver.GetName();
    name.Replace("PanelWidget", "Render");
    ItemPreviewWidget receiver_iw = ItemPreviewWidget.Cast(receiver.FindAnyWidget(name));
    if (receiver_iw)
      receiver_item = ItemBase.Cast(receiver_iw.GetItem());
 
    SlotsIcon slots_icon;
    receiver.GetUserData(slots_icon);
 
    if (receiver_item)
    {
      int stack_max = InventorySlots.GetStackMaxForSlotId(receiver_item.GetInventory().GetSlotId(0));
      //int quantity = receiver_item.GetQuantity();
      //bool combinable = ( quantity < stack_max ) && ( ItemBase.Cast( receiver_item ).CanBeCombined( ItemBase.Cast( iw.GetItem() ) ) );
      if (receiver_item.CanBeCombined(ItemBase.Cast(iw.GetItem())))
      {
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetLeftDropzone().SetAlpha(1);
        ColorManager.GetInstance().SetColor(w, ColorManager.COMBINE_COLOR);
      }
      else if (stack_max == 0 && GameInventory.CanSwapEntitiesEx(receiver_item, iw.GetItem()))
      {
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetLeftDropzone().SetAlpha(1);
        ColorManager.GetInstance().SetColor(w, ColorManager.SWAP_COLOR);
      }
      else
      {
        ItemManager.GetInstance().ShowSourceDropzone(iw.GetItem());
        ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
      }
    }
    else if (slots_icon && slots_icon.GetSlotID() != -1)
    {
      item = ItemBase.Cast(iw.GetItem());
 
      if (item && m_Entity.GetInventory().CanAddAttachmentEx(item, slots_icon.GetSlotID()))
      {
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetLeftDropzone().SetAlpha(1);
        ColorManager.GetInstance().SetColor(w, ColorManager.GREEN_COLOR);
      }
      else
      {
        ItemManager.GetInstance().ShowSourceDropzone(iw.GetItem());
        ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
      }
    }
    else
    {
      ItemManager.GetInstance().ShowSourceDropzone(iw.GetItem());
      ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
    }
  }
 
  bool DraggingOverGrid(Widget w, int x, int y, Widget reciever, CargoContainer cargo)
  {
    if (w == null)
      return false;
 
    EntityAI item = GetItemPreviewItem(w);
 
    if (!item)
      return false;
 
    int color;
    int idx = 0;
    int c_x, c_y;
 
    EntityAI target_entity;
    CargoBase target_cargo;
 
    target_entity = cargo.GetEntity() ;
    if (target_entity)
      target_cargo = target_entity.GetInventory().GetCargo();
    else
      return false;
 
    if (target_cargo && target_entity)
    {
      c_x = target_cargo.GetHeight();
      c_y = target_cargo.GetWidth();
    }
    else
      return false;
 
    if (c_x > x && c_y > y && target_entity.GetInventory().CanAddEntityInCargoEx(item, idx, x, y, item.GetInventory().GetFlipCargo()))
      color = ColorManager.GREEN_COLOR;
    else
      color = ColorManager.RED_COLOR;
 
    if (w.FindAnyWidget("Cursor"))
      w.FindAnyWidget("Cursor").SetColor(color);
    else
    {
      string name = w.GetName();
      name.Replace("PanelWidget", "Cursor");
      if (w.FindAnyWidget(name))
        w.FindAnyWidget(name).SetColor(color);
    }
 
    return true;
  }
 
  void DropReceived(Widget w, int x, int y, CargoContainer cargo)
  {
    EntityAI item = GetItemPreviewItem(w);
    if (!item)
      return;
 
    int idx = 0;
    int c_x, c_y;
 
    EntityAI target_entity;
    CargoBase target_cargo;
 
    target_entity = cargo.GetEntity();
    if (target_entity)
      target_cargo = target_entity.GetInventory().GetCargo();
    else
      return;
 
    if (target_cargo && target_entity)
    {
      c_x = target_cargo.GetHeight();
      c_y = target_cargo.GetWidth();
    }
    else
      return;
 
    InventoryLocation dst = new InventoryLocation;
    dst.SetCargoAuto(target_cargo, item, x, y, item.GetInventory().GetFlipCargo());
 
    if (c_x > x && c_y > y && target_entity.GetInventory().LocationCanAddEntity(dst))
    {
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
      SplitItemUtils.TakeOrSplitToInventoryLocation(player, dst);
 
      Icon icon = cargo.GetIcon(item);
 
      if (icon)
      {
        icon.GetCursorWidget().SetColor(ColorManager.BASE_COLOR);
        icon.RefreshPos(x, y);
        icon.Refresh();
        Refresh();
      }
    }
  }
 
  EntityAI GetItemPreviewItem(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);
    if (!ipw || !ipw.IsInherited(ItemPreviewWidget))
      return null;
    return ipw.GetItem();
  }
 
  override void Refresh()
  {
    if (!m_Refreshing)
    {
      if (!m_Closed)
      {
        super.Refresh();
        RefreshAllSlots();
      }
    }
  }
 
  void RefreshAllSlots()
  {
    m_Refreshing = true;
    int row_count = m_AttachmentsContainer.GetRowCount();
    int row;
    for (row = 0; row < row_count; row++)
    {
      int col_count = m_AttachmentsContainer.GetColumnCountForRow(row);
      int col;
      for (col = 0; col < col_count; col++)
        RefreshSlot(row, col, -1, "");
    }
    m_Refreshing = false;
  }
 
  //slot_id and slot_name parametr is not used
  void RefreshSlot(int row, int column, int slot_id, string slot_name)
  {
    SlotsIcon icon = m_AttachmentsContainer.GetSlotsIcon(row, column);
    int slot_id_ = icon.GetSlotID();
    EntityAI item = m_Entity.GetInventory().FindAttachment(slot_id_);
    ContainerWithCargo cont;
 
    if (!m_Entity.CanDisplayAttachmentSlot(slot_id_))
    {
      icon.Clear();
      icon.GetMainWidget().Show(false);
    }
    else if (!item)
    {
      if (icon.GetEntity())
      {
        icon.ClearRemainSelected();
 
        cont = m_AttachmentCargos.Get(slot_id_);
        if (cont)
        {
          m_AttachmentCargos.Remove(slot_id_);
          this.Remove(cont);
          (Container.Cast(cont.m_Parent)).Remove(cont);
        }
      }
      icon.GetMainWidget().Show(true);
    }
    else
    {
      icon.GetMainWidget().Show(true);
      if (icon.GetEntity() != item)
        icon.Init(item);
      else
        icon.Refresh();
 
      cont = m_AttachmentCargos.Get(slot_id_);
      if (cont && cont.GetEntity() != item)
      {
        m_AttachmentCargos.Remove(slot_id_);
        (Container.Cast(cont.m_Parent)).Remove(cont);
        this.Remove(cont);
        cont = null;
      }
 
      if (!cont)
      {
        if (item.GetInventory().GetCargo() && m_AttachmentCargos)
        {
          cont = new ContainerWithCargo(this, true);
          cont.GetRootWidget().SetSort(m_AttachmentCargos.Count() + 10);
          cont.SetEntity(item);
          cont.SetSlotIcon(icon);
 
          m_AttachmentCargos.Insert(slot_id_, cont);
          icon.SetContainer(cont);
 
          SetOpenForSlotIcon(cont.IsOpened(), icon);
        }
      }
 
      if (cont)
        icon.GetRadialIconPanel().Show(cont.IsDisplayable());
 
      string slot_name_ = InventorySlots.GetSlotName(slot_id_);
      bool draggable = true;
      bool can_be_removed = item.GetInventory().CanRemoveEntity();
      bool in_hands_condition = m_Entity.GetHierarchyRoot() == GetGame().GetPlayer();
      bool in_vicinity_condition = AttachmentsOutOfReach.IsAttachmentReachable(m_Entity, slot_name_);
      if (m_Entity.GetInventory().GetSlotLock(slot_id_) && ItemManager.GetInstance().GetDraggedItem() != item)
      {
        icon.GetMountedWidget().Show(true);
        draggable = false;
      }
      else
        icon.GetMountedWidget().Show(false);
 
      if (!m_Entity.CanReleaseAttachment(item))
        draggable = false;
 
      if ((in_hands_condition || in_vicinity_condition) && can_be_removed)
        icon.GetOutOfReachWidget().Show(false);
      else
      {
        icon.GetOutOfReachWidget().Show(true);
        draggable = false;
      }
 
      if (draggable)
        icon.GetRender().GetParent().SetFlags(WidgetFlags.DRAGGABLE);
      else
        icon.GetRender().GetParent().ClearFlags(WidgetFlags.DRAGGABLE);
    }
  }
 
  void DoubleClick(Widget w, int x, int y, int button)
  {
    if (button == MouseState.LEFT && !g_Game.IsLeftCtrlDown())
    {
      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);
 
      SlotsIcon icon;
      w.GetUserData(icon);
 
      if (icon && m_Entity.GetInventory().GetSlotLock(iw.GetUserID()))
        return;
 
      if (icon.IsOutOfReach())
        return;
 
      ItemBase item = ItemBase.Cast(iw.GetItem());
      if (item)
      {
        if (!item.GetInventory().CanRemoveEntity())
          return;
 
        PlayerBase controlledPlayer = PlayerBase.Cast(GetGame().GetPlayer());
        if (controlledPlayer.GetInventory().HasEntityInInventory(item) && controlledPlayer.GetHumanInventory().CanAddEntityInHands(item))
          controlledPlayer.PredictiveTakeEntityToHands(item);
        else
        {
          if (controlledPlayer.GetInventory().CanAddEntityToInventory(item) && item.GetInventory().CanRemoveEntity())
          {
            if (item.GetTargetQuantityMax() < item.GetQuantity())
              item.SplitIntoStackMaxClient(controlledPlayer, -1);
            else
              controlledPlayer.PredictiveTakeEntityToInventory(FindInventoryLocationType.ANY, item);
          }
          else
          {
            if (controlledPlayer.GetHumanInventory().CanAddEntityInHands(item))
            {
              if (item.GetTargetQuantityMax() < item.GetQuantity())
                item.SplitIntoStackMaxHandsClient(controlledPlayer);
              else
                controlledPlayer.PredictiveTakeEntityToHands(item);
            }
          }
        }
 
        HideOwnedTooltip();
 
        name = w.GetName();
        name.Replace("PanelWidget", "Temperature");
        w.FindAnyWidget(name).Show(false);
      }
    }
  }
 
  void MouseClick(Widget w, int x, int y, int button)
  {
    ItemBase selectedItem;
    SlotsIcon icon;
    w.GetUserData(icon);
    if (icon)
      selectedItem = ItemBase.Cast(icon.GetEntity());
 
    if (selectedItem)
    {
      switch (button)
      {
      case MouseState.RIGHT:
#ifdef DIAG_DEVELOPER
        if (g_Game.IsLeftCtrlDown())
          ShowActionMenu(selectedItem);
#endif
 
        break;
 
      case MouseState.MIDDLE:
        InspectItem(selectedItem);
        break;
 
      case MouseState.LEFT:
        PlayerBase controlledPlayer = PlayerBase.Cast(GetGame().GetPlayer());
        if (g_Game.IsLeftCtrlDown())
        {
          if (icon.IsOutOfReach())
            return;
 
          if (controlledPlayer.CanDropEntity(selectedItem))
          {
            if (selectedItem.GetTargetQuantityMax() < selectedItem.GetQuantity())
              selectedItem.SplitIntoStackMaxClient(null, -1);
            else
              controlledPlayer.PhysicalPredictiveDropItem(selectedItem);
          }
          else
          {
            bool draggable = !controlledPlayer.GetInventory().HasInventoryReservation(selectedItem, null) && !controlledPlayer.GetInventory().IsInventoryLocked() && selectedItem.GetInventory().CanRemoveEntity() && !controlledPlayer.IsItemsToDelete();
            ItemManager.GetInstance().SetWidgetDraggable(w, draggable);
          }
        }
        else
        {
          ClosableContainer c = ClosableContainer.Cast(icon.GetContainer());
          if (c)
            c.Toggle();
        }
 
        break;
      }
    }
  }
 
  void Init(int attachments_categories_count, int i, string attachment_category, string config_path_attachment_categories, EntityAI entity, int parent_m_Body_count)
  {
    m_Entity = entity;
    Header header = GetHeader();
 
    m_CategoryIdentifier = attachment_category;
 
    array<string> player_ghosts_slots2 = new array<string>();
    string categoryName;
 
    m_RowConfigPath = config_path_attachment_categories + " " + attachment_category + " attachmentSlots";
    string config_path_category_name = config_path_attachment_categories + " " + attachment_category + " name";
    GetGame().ConfigGetTextArray(m_RowConfigPath, player_ghosts_slots2);
    GetGame().ConfigGetText(config_path_category_name, categoryName);
    header.SetName(categoryName);
 
    m_AttachmentsContainer.SetHeader(header);
    SetHeader(null);
 
    int count = player_ghosts_slots2.Count();
    int lastRow = count / ITEMS_IN_ROW;
    SlotsContainer slotsContainer;
 
    for (int j = 0; j < count; j++)
    {
      string slotName = player_ghosts_slots2.Get(j);
      string iconName; //must be in format "set:<setname> image:<imagename>"
      string path = "CfgSlots" + " Slot_" + slotName;
 
      int slotId = InventorySlots.GetSlotIdFromString(slotName);
 
      GetGame().ConfigGetText(path + " ghostIcon", iconName);
      GetGame().ConfigGetText(path + " name", slotName);
 
      int row = j / ITEMS_IN_ROW;
      int column = j % ITEMS_IN_ROW;
      if (column == 0)
      {
        slotsContainer = new SlotsContainer(m_AttachmentsContainer, m_Entity);
        slotsContainer.GetRootWidget().SetAlpha(0.7);
        if (row == lastRow)
          slotsContainer.SetColumnCount(count % ITEMS_IN_ROW);
        else
          slotsContainer.SetColumnCount(ITEMS_IN_ROW);
 
        m_AttachmentsContainer.Insert(slotsContainer);
        slotsContainer.GetRootWidget().SetSort(row);
      }
 
      SlotsIcon icon = slotsContainer.GetSlotIcon(column);
      WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetMainWidget(), this, "OnDropReceivedFromHeader");
      WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetGhostSlot(), this, "OnDropReceivedFromHeader");
      WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetPanelWidget(), this, "OnDropReceivedFromHeader");
 
      WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetMainWidget(), this, "DraggingOverHeader");
      WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetGhostSlot(), this, "DraggingOverHeader");
      WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetPanelWidget(), this, "DraggingOverHeader");
 
      WidgetEventHandler.GetInstance().RegisterOnDrop(icon.GetMainWidget(), this, "OnIconDrop");
      WidgetEventHandler.GetInstance().RegisterOnDrop(icon.GetPanelWidget(), this, "OnIconDrop");
 
      WidgetEventHandler.GetInstance().RegisterOnDoubleClick(icon.GetPanelWidget(), this, "DoubleClick");
      WidgetEventHandler.GetInstance().RegisterOnMouseButtonUp(icon.GetPanelWidget(), this, "MouseClick");
 
      icon.GetGhostSlot().LoadImageFile(0, StaticGUIUtils.VerifyIconImageString(StaticGUIUtils.IMAGESETGROUP_INVENTORY, iconName));
      icon.SetSlotID(slotId);
      icon.SetSlotDisplayName(InventorySlots.GetSlotDisplayName(slotId));
 
      icon.Clear();
    }
    RefreshAllSlots();
  }
 
  override void UpdateInterval()
  {
    super.UpdateInterval();
    RefreshAllSlots();
  }
}