HandsContainer.c

Go to the documentation of this file.

class HandsContainer: Container
{
  protected bool m_Hidden;
  protected ref HandsHeader m_CollapsibleHeader;
  protected ref HandsPreview m_HandsPreview;
 
  protected ref Attachments m_Atts;
  protected ref CargoContainer m_CargoGrid;
 
  protected ref map<EntityAI, ref CargoContainer> m_AttachmentCargos;
  protected ref map<EntityAI, AttachmentsWrapper> m_AttachmentAttachmentsContainers;
  protected ref map<EntityAI, ref Attachments> m_AttachmentAttachments;
  protected ref array<int> m_AttachmentSlotsSorted;
 
  protected int m_StaticAttCount = 0;
  protected int m_StaticCargoCount = 0;
 
  protected ScrollWidget m_ScrollWidget;
 
  void HandsContainer(LayoutHolder parent)
  {
    m_AttachmentCargos = new map<EntityAI, ref CargoContainer>;
    m_AttachmentAttachmentsContainers = new map<EntityAI, AttachmentsWrapper>;
    m_AttachmentAttachments = new map<EntityAI, ref Attachments>;
 
    m_CollapsibleHeader = new HandsHeader(this, "CollapseButtonOnMouseButtonDown");
    GetMainWidget().SetFlags(WidgetFlags.IGNOREPOINTER);
    m_MainWidget = m_MainWidget.FindWidget("body");
    GetMainWidget().SetFlags(WidgetFlags.IGNOREPOINTER);
    m_Body = new array<ref LayoutHolder>;
    m_HandsPreview = new HandsPreview(this);
    ItemManager.GetInstance().SetHandsPreview(m_HandsPreview);
    m_Body.Insert(m_HandsPreview);
 
    ItemBase hands_item = ItemBase.Cast(GetGame().GetPlayer().GetHumanInventory().GetEntityInHands());
    if (hands_item)
      m_HandsPreview.CreateNewIcon(hands_item);
 
    m_ScrollWidget = ScrollWidget.Cast(m_RootWidget.GetParent().GetParent());
    RecomputeOpenedContainers();
  }
 
  void ~HandsContainer()
  {
    if (m_Entity)
    {
      m_Entity.GetOnItemAttached().Remove(AttachmentAdded);
      m_Entity.GetOnItemDetached().Remove(AttachmentRemoved);
    }
 
    m_AttachmentCargos.Clear();
    m_AttachmentAttachmentsContainers.Clear();
    m_AttachmentAttachments.Clear();
  }
 
  void ResetContainer()
  {
    m_Body.Clear();
    m_Body.Insert(m_HandsPreview);
  }
 
  override Header GetHeader()
  {
    return m_CollapsibleHeader;
  }
 
  override bool IsLastIndex()
  {
    return m_ActiveIndex == m_OpenedContainers.Count() - 1;
  }
 
  void SetFocusToIndex()
  {
    int index = m_ActiveIndex - 1;
    int attachment_start_index = -1;
    int cargo_start_index = -1;
    int attachment_end_index = -1;
    int cargo_end_index = -1;
 
    if (m_Atts || m_AttachmentAttachments.Count() > 0)
    {
      attachment_start_index = 0;
      if (m_Atts)
        attachment_end_index++;
      attachment_end_index += m_AttachmentAttachments.Count();
    }
 
    if (m_CargoGrid || m_AttachmentCargos.Count() > 0)
    {
      cargo_start_index = attachment_end_index + 1;
      if (m_CargoGrid)
        cargo_end_index++;
      cargo_end_index += cargo_start_index + m_AttachmentCargos.Count();
    }
 
    if (m_ActiveIndex > m_OpenedContainers.Count())
      m_ActiveIndex = m_OpenedContainers.Count();
 
    if (index == -1)
    {
#ifdef PLATFORM_CONSOLE
      if (m_MainWidget.FindAnyWidget("Cursor"))
        m_MainWidget.FindAnyWidget("Cursor").Show(true);
#endif
      m_ScrollWidget.VScrollToPos01(0);
    }
    else
    {
      if (index.InRange(0, attachment_end_index))
      {
        if (m_Atts)
        {
          if (index == 0)
          {
            m_Atts.SetDefaultFocus();
            SetFocusedContainer(m_Atts.GetWrapper());
          }
          else
          {
            m_AttachmentAttachments.GetElement(index - 1).SetDefaultFocus();
            SetFocusedContainer(m_AttachmentAttachments.GetElement(index - 1).GetWrapper());
          }
        }
        else
        {
          m_AttachmentAttachments.GetElement(index).SetDefaultFocus();
          SetFocusedContainer(m_AttachmentAttachments.GetElement(index).GetWrapper());
        }
      }
      else if (index.InRange(cargo_start_index, cargo_end_index))
      {
        if (m_CargoGrid)
        {
          if (index == cargo_start_index)
          {
            m_CargoGrid.SetDefaultFocus();
            SetFocusedContainer(m_CargoGrid);
          }
          else
          {
            m_AttachmentCargos.GetElement(index - 1 - cargo_start_index).SetDefaultFocus();
            SetFocusedContainer(m_AttachmentCargos.GetElement(index - 1 - cargo_start_index));
          }
        }
        else
        {
          m_AttachmentCargos.GetElement(index - cargo_start_index).SetDefaultFocus();
          SetFocusedContainer(m_AttachmentCargos.GetElement(index - cargo_start_index));
        }
      }
 
      if (m_MainWidget.FindAnyWidget("Cursor"))
        m_MainWidget.FindAnyWidget("Cursor").Show(false);
      ScrollToActiveContainer(GetFocusedContainer());
    }
  }
 
  void ScrollToActiveContainer(Container active_container)
  {
    if (!active_container)
      return;
    float x, y, y_s;
    m_ScrollWidget.GetScreenPos(x, y);
    m_ScrollWidget.GetScreenSize(x, y_s);
    float amount;
    float next_pos = active_container.GetFocusedContainerYScreenPos(true) + active_container.GetFocusedContainerHeight(true);
 
    if (next_pos > (y + y_s))
    {
      amount = y + active_container.GetFocusedContainerYScreenPos(true);
      m_ScrollWidget.VScrollToPos(m_ScrollWidget.GetVScrollPos() + active_container.GetFocusedContainerHeight(true) + 2);
    }
    else if (active_container.GetFocusedContainerYScreenPos(true) < y)
    {
      amount = active_container.GetFocusedContainerYScreenPos(true) - y;
      m_ScrollWidget.VScrollToPos(m_ScrollWidget.GetVScrollPos() + amount - 2);
    }
  }
 
  override void Insert(LayoutHolder container, int pos = -1, bool immedUpdate = true)
  {
    super.Insert(container, pos, immedUpdate);
  }
 
  override bool TransferItem()
  {
    if (m_ActiveIndex == 0)
    {
      if (CanTakeToInventory())
      {
        EntityAI item_in_hands = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
        if (item_in_hands && GetGame().GetPlayer().GetHumanInventory().CanRemoveEntityInHands() && !GetGame().GetPlayer().GetInventory().HasInventoryReservation(item_in_hands, null))
        {
          if (GetGame().GetPlayer().PredictiveTakeEntityToInventory(FindInventoryLocationType.CARGO, item_in_hands))
          {
            m_MainWidget.FindAnyWidget("Cursor").Show(false);
            m_MainWidget.FindAnyWidget("hands_preview_root").SetAlpha(0.7);
            return true;
          }
        }
      }
    }
    else if (GetFocusedContainer())
      return GetFocusedContainer().TransferItem();
    return false;
  }
 
  override bool SplitItem()
  {
    if (CanSplit())
    {
      if (m_ActiveIndex == 0)
      {
        ItemBase item_in_hands = ItemBase.Cast(GetGame().GetPlayer().GetHumanInventory().GetEntityInHands());
        if (item_in_hands)
        {
          if (item_in_hands.CanBeSplit())
            item_in_hands.OnRightClick();
        }
      }
      else if (GetFocusedContainer())
        return GetFocusedContainer().SplitItem();
    }
    return false;
  }
 
  override bool EquipItem()
  {
    if (CanEquip())
    {
      if (m_ActiveIndex == 0)
      {
        ItemBase item_in_hands = ItemBase.Cast(GetGame().GetPlayer().GetHumanInventory().GetEntityInHands());
        if (item_in_hands)
        {
          if (GetGame().GetPlayer().GetHumanInventory().CanRemoveEntityInHands() && !GetGame().GetPlayer().GetInventory().HasInventoryReservation(item_in_hands, null))
          {
            if (GetGame().GetPlayer().PredictiveTakeEntityToInventory(FindInventoryLocationType.ATTACHMENT, item_in_hands))
            {
              m_MainWidget.FindAnyWidget("Cursor").Show(false);
              m_MainWidget.FindAnyWidget("hands_preview_root").SetAlpha(0.7);
              return true;
            }
          }
        }
      }
      else if (GetFocusedContainer())
        return GetFocusedContainer().EquipItem();
    }
    return false;
  }
 
  override void SetActive(bool active)
  {
    super.SetActive(active);
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    EntityAI item_in_hands = player.GetHumanInventory().GetEntityInHands();
 
    if (item_in_hands)
    {
      if (m_MainWidget.FindAnyWidget("Cursor"))
        m_MainWidget.FindAnyWidget("Cursor").Show(active);
 
      if (active)
      {
        float x, y;
        GetMainWidget().GetScreenPos(x, y);
        PrepareOwnedTooltip(item_in_hands, -1, y);
      }
    }
    else
    {
      if (active)
        m_MainWidget.FindAnyWidget("hands_preview_root").SetAlpha(0.85);
      else
        m_MainWidget.FindAnyWidget("hands_preview_root").SetAlpha(0.7);
    }
  }
 
  override void SetLastActive()
  {
    super.SetLastActive();
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    EntityAI item_in_hands = player.GetHumanInventory().GetEntityInHands();
 
    if (item_in_hands)
    {
      if (m_ActiveIndex == 0)
      {
        if (m_MainWidget.FindAnyWidget("Cursor"))
          m_MainWidget.FindAnyWidget("Cursor").Show(true);
 
        float x, y;
        GetMainWidget().GetScreenPos(x, y);
        PrepareOwnedTooltip(item_in_hands, x, y);
      }
    }
    else
      m_MainWidget.FindAnyWidget("hands_preview_root").SetAlpha(0.85);
  }
 
  override void Refresh()
  {
    super.Refresh();
    SetActive(m_IsActive);
  }
 
  override bool IsItemActive()
  {
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    ItemBase item = ItemBase.Cast(player.GetHumanInventory().GetEntityInHands());
    if (item == null)
      return false;
    return !IsEmpty() && (!QuantityConversions.HasItemQuantity(item) || (QuantityConversions.HasItemQuantity(item) && !item.CanBeSplit()));
  }
 
  override bool IsItemWithQuantityActive()
  {
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    ItemBase item = ItemBase.Cast(player.GetHumanInventory().GetEntityInHands());
    if (item == null)
      return false;
    return !IsEmpty() && QuantityConversions.HasItemQuantity(item) && item.CanBeSplit();
  }
 
  override bool IsEmpty()
  {
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    return player.GetHumanInventory().GetEntityInHands() == null;
  }
 
  override bool TransferItemToVicinity()
  {
    if (CanDrop())
    {
      if (m_ActiveIndex == 0)
      {
        PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
        ItemBase item_in_hands = ItemBase.Cast(player.GetHumanInventory().GetEntityInHands());
        if (item_in_hands && player.CanDropEntity(item_in_hands) && GetGame().GetPlayer().GetHumanInventory().CanRemoveEntityInHands() && !player.GetInventory().HasInventoryReservation(item_in_hands, null))
        {
          if (item_in_hands.GetTargetQuantityMax() < item_in_hands.GetQuantity())
            item_in_hands.SplitIntoStackMaxClient(null, -1);
          else
            player.PhysicalPredictiveDropItem(item_in_hands);
          m_MainWidget.FindAnyWidget("Cursor").Show(false);
          m_MainWidget.FindAnyWidget("hands_preview_root").SetAlpha(0.7);
          return true;
        }
      }
      else if (GetFocusedContainer())
        return GetFocusedContainer().TransferItemToVicinity();
    }
    return false;
  }
 
  override bool InspectItem()
  {
    if (m_ActiveIndex == 0)
    {
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
      EntityAI item_in_hands = player.GetHumanInventory().GetEntityInHands();
      if (item_in_hands)
      {
        InspectItem(item_in_hands);
        return true;
      }
    }
    else if (GetFocusedContainer())
      return GetFocusedContainer().InspectItem();
    return false;
  }
 
  override bool OnSelectButton()
  {
    if (m_ActiveIndex == 0)
    {
      if (ItemManager.GetInstance().IsMicromanagmentMode())
      {
        EntityAI selectedItem = ItemManager.GetInstance().GetSelectedItem();
        if (selectedItem == GetFocusedItem())
        {
          Inventory.GetInstance().DisableMicromanagement();
          return true;
        }
        else
          return Select();
      }
      else
      {
        Inventory.GetInstance().EnableMicromanagement();
        return true;
      }
    }
    else
    {
      if (GetFocusedContainer())
        return GetFocusedContainer().OnSelectButton();
    }
    return false;
  }
 
  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)
      return null;
 
    return ipw.GetItem();
  }
 
  override void DraggingOverHeader(Widget w, int x, int y, Widget receiver)
  {
    if (w == null)
      return;
    EntityAI receiver_item;
    EntityAI slot_owner;
    int slot_id = -1;
 
    string name = w.GetName();
    name.Replace("PanelWidget", "Render");
 
    ItemPreviewWidget w_ipw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
    if (w_ipw == null)
      w_ipw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
    if (w_ipw == null)
      return;
 
    SlotsIcon slots_icon;
    receiver.GetUserData(slots_icon);
 
    if (slots_icon)
    {
      receiver_item = slots_icon.GetEntity();
      slot_id = slots_icon.GetSlotID();
      slot_owner = slots_icon.GetSlotParent();
    }
 
 
    PlayerBase p = PlayerBase.Cast(GetGame().GetPlayer());
    InventoryItem receiver_entity = InventoryItem.Cast(p.GetHumanInventory().GetEntityInHands());
    InventoryItem w_entity = InventoryItem.Cast(w_ipw.GetItem());
    if (!w_entity)
      return;
 
    if (receiver_entity)
    {
      if (receiver_item)
      {
        ItemBase receiver_itemIB = ItemBase.Cast(receiver_item);
        ItemBase itemIB = ItemBase.Cast(receiver_item);
        if (receiver_itemIB && itemIB && receiver_itemIB.CanBeCombined(itemIB))
        {
          ItemManager.GetInstance().HideDropzones();
          if (m_Entity.GetHierarchyRootPlayer() == GetGame().GetPlayer())
            ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
          else
            ItemManager.GetInstance().GetLeftDropzone().SetAlpha(1);
          ColorManager.GetInstance().SetColor(w, ColorManager.COMBINE_COLOR);
        }
        else
        {
          PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
          Magazine mag = Magazine.Cast(receiver_item);
          Weapon_Base wpn = Weapon_Base.Cast(receiver_item.GetHierarchyParent());
 
          if (wpn && mag)
          {
            if (player.GetWeaponManager().CanSwapMagazine(wpn, Magazine.Cast(w_entity)))
            {
              ColorManager.GetInstance().SetColor(w, ColorManager.SWAP_COLOR);
              if (w_entity.GetHierarchyRootPlayer() == player)
                ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
              else
                ItemManager.GetInstance().GetLeftDropzone().SetAlpha(1);
            }
            else
            {
              ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
              ItemManager.GetInstance().ShowSourceDropzone(w_entity);
            }
          }
          else
          {
            if (GameInventory.CanSwapEntitiesEx(receiver_item, w_entity))
            {
              ItemManager.GetInstance().HideDropzones();
              if (m_Entity.GetHierarchyRootPlayer() == GetGame().GetPlayer())
                ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
              else
                ItemManager.GetInstance().GetLeftDropzone().SetAlpha(1);
              ColorManager.GetInstance().SetColor(w, ColorManager.SWAP_COLOR);
            }
            else if (receiver_itemIB.GetInventory().CanAddAttachment(w_entity))
            {
              ItemManager.GetInstance().HideDropzones();
              if (receiver_itemIB.GetHierarchyRootPlayer() == GetGame().GetPlayer())
                ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
              else
                ItemManager.GetInstance().GetLeftDropzone().SetAlpha(1);
              ColorManager.GetInstance().SetColor(w, ColorManager.GREEN_COLOR);
            }
          }
        }
      }
      else if (slot_owner && slot_owner.GetInventory().CanAddAttachment(w_entity))
      {
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetCenterDropzone().SetAlpha(1);
        ColorManager.GetInstance().SetColor(w, ColorManager.GREEN_COLOR);
      }
      else if (receiver_entity.GetInventory().CanAddAttachment(w_entity))
      {
        ItemManager.GetInstance().HideDropzones();
        if (receiver_entity.GetHierarchyRootPlayer() == GetGame().GetPlayer())
          ItemManager.GetInstance().GetRightDropzone().SetAlpha(1);
        else
          ItemManager.GetInstance().GetLeftDropzone().SetAlpha(1);
        ColorManager.GetInstance().SetColor(w, ColorManager.GREEN_COLOR);
      }
      else
      {
        ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
        ItemManager.GetInstance().ShowSourceDropzone(w_entity);
      }
    }
    else
    {
      /*if( m_HandsIcon )
        {
        ColorManager.GetInstance().SetColor( w, ColorManager.SWAP_COLOR );
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetCenterDropzone().SetAlpha( 1 );
        }
 
        else
        {*/
      ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
      ItemManager.GetInstance().ShowSourceDropzone(w_entity);
      //}
    }
  }
 
  void OnDropReceivedFromHeader2(Widget w, int x, int y, Widget receiver)
  {
    TakeAsAttachment(w, receiver);
  }
 
  void OnPerformCombination(int combinationFlags)
  {
    PlayerBase m_player = PlayerBase.Cast(GetGame().GetPlayer());
    if (m_am_entity1 == null || m_am_entity2 == null) return;
 
    if (combinationFlags == InventoryCombinationFlags.NONE) return;
 
    if (combinationFlags & InventoryCombinationFlags.LOAD_CHAMBER)
    {
      Magazine mag;
      if (Class.CastTo(mag, m_am_entity2))
      {
        m_player.GetWeaponManager().LoadBullet(mag);
        return;
      }
    }
 
    if (combinationFlags & InventoryCombinationFlags.ADD_AS_ATTACHMENT)
    {
      if (m_Atts)
      {
        m_Body.RemoveItem(m_Atts.GetWrapper());
        delete m_Atts;
      }
      if (m_am_entity2.GetSlotsCountCorrect() > 0)
      {
        m_Atts = new Attachments(this, m_am_entity2);
        m_Atts.InitAttachmentGrid(1);
 
      }
 
      Refresh();
      m_Parent.Refresh();
 
      Weapon_Base wpn1;
      Magazine mag1;
      if (Class.CastTo(wpn1, m_am_entity1) && Class.CastTo(mag1, m_am_entity2))
      {
        if (m_player.GetWeaponManager().CanAttachMagazine(wpn1, mag1))
        {
          m_player.GetWeaponManager().AttachMagazine(mag1);
          return;
        }
      }
 
      SplitItemUtils.TakeOrSplitToInventory(m_player, m_am_entity1, m_am_entity2);
      //m_player.PredictiveTakeEntityToTargetAttachment( m_am_entity1, m_am_entity2 );
    }
 
    if (combinationFlags & InventoryCombinationFlags.ADD_AS_CARGO)
      m_player.PredictiveTakeEntityToTargetCargo(m_am_entity1, m_am_entity2);
 
    if (combinationFlags & InventoryCombinationFlags.SWAP)
    {
      Magazine swapmag1;
      Magazine swapmag2;
      if (Class.CastTo(swapmag1, m_am_entity1) && Class.CastTo(swapmag2, m_am_entity2))
      {
        if (m_player.GetWeaponManager().CanSwapMagazine(Weapon_Base.Cast(swapmag1.GetParent()), Magazine.Cast(swapmag2)))
        {
          m_player.GetWeaponManager().SwapMagazine(swapmag2);
          return;
        }
 
        if (m_player.GetWeaponManager().CanSwapMagazine(Weapon_Base.Cast(swapmag2.GetParent()), Magazine.Cast(swapmag1)))
        {
          m_player.GetWeaponManager().SwapMagazine(swapmag1);
          return;
        }
      }
      if (!m_player.PredictiveSwapEntities(m_am_entity1, m_am_entity2) && m_player.GetHumanInventory().CanAddEntityInHands(m_am_entity1))
        m_player.PredictiveTakeEntityToHands(m_am_entity1);
    }
 
    if (combinationFlags & InventoryCombinationFlags.TAKE_TO_HANDS)
    {
      if (m_Atts)
      {
        m_Body.RemoveItem(m_Atts.GetWrapper());
        delete m_Atts;
      }
 
      if (m_am_entity2.GetSlotsCountCorrect() > 0)
      {
        m_Atts = new Attachments(this, m_am_entity2);
        m_Atts.InitAttachmentGrid(1);
 
      }
      Refresh();
      m_Parent.Refresh();
 
      if (m_player.GetHumanInventory().CanAddEntityInHands(m_am_entity2))
        m_player.PredictiveTakeEntityToHands(m_am_entity2);
    }
  }
 
  void ShowActionMenuCombine(EntityAI entity1, EntityAI entity2, int combinationFlags)
  {
    if (entity1 && entity2) PrintString("Showing action menu for " + entity1.GetDisplayName() + " and " + entity2.GetDisplayName());
 
    ContextMenu cmenu = ContextMenu.Cast(GetGame().GetUIManager().GetMenu().GetContextMenu());
    m_am_entity1 = entity1;
    m_am_entity2 = entity2;
    cmenu.Hide();
    cmenu.Clear();
 
    if (combinationFlags & InventoryCombinationFlags.COMBINE_QUANTITY2)
    {
      ItemBase entity = ItemBase.Cast(entity1);
      entity.CombineItemsClient(ItemBase.Cast(entity2));
      return;
    }
 
    if (entity1 == null || entity2 == null) return;
 
    if (combinationFlags == InventoryCombinationFlags.NONE) return;
 
    if (combinationFlags & InventoryCombinationFlags.ADD_AS_ATTACHMENT)
      cmenu.Add("#inv_context_add_as_attachment", this, "OnPerformCombination", new Param1<int>(InventoryCombinationFlags.ADD_AS_ATTACHMENT));
    if (combinationFlags & InventoryCombinationFlags.LOAD_CHAMBER)
      cmenu.Add("#inv_context_load_chamber", this, "OnPerformCombination", new Param1<int>(InventoryCombinationFlags.LOAD_CHAMBER));
 
    if (combinationFlags & InventoryCombinationFlags.ADD_AS_CARGO)
      cmenu.Add("#inv_context_add_as_cargo", this, "OnPerformCombination", new Param1<int>(InventoryCombinationFlags.ADD_AS_CARGO));
 
    if (combinationFlags & InventoryCombinationFlags.SWAP)
      cmenu.Add("#inv_context_swap", this, "OnPerformCombination", new Param1<int>(InventoryCombinationFlags.SWAP));
 
    if (combinationFlags & InventoryCombinationFlags.TAKE_TO_HANDS)
      cmenu.Add("#inv_context_take_to_hands", this, "OnPerformCombination", new Param1<int>(InventoryCombinationFlags.TAKE_TO_HANDS));
 
    if (combinationFlags & InventoryCombinationFlags.COMBINE_QUANTITY2)
      cmenu.Add("#inv_context_combine", this, "OnPerformCombination", new Param1<int>(InventoryCombinationFlags.COMBINE_QUANTITY2));
 
    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;
 
    cmenu.Show(m_am_pos_x, m_am_pos_y);
  }
 
 
  override void OnDropReceivedFromHeader(Widget w, int x, int y, Widget receiver)
  {
    TakeAsAttachment(w, receiver);
  }
 
  int GetCombinationFlags(EntityAI entity1, EntityAI entity2)
  {
    int flags = 0;
    PlayerBase m_player = PlayerBase.Cast(GetGame().GetPlayer());
    EntityAI entity_in_hands = m_player.GetHumanInventory().GetEntityInHands();
 
    if (!entity1 || !entity2) return flags;
 
    Magazine swapmag1;
    Magazine swapmag2;
    bool skipSwap = false;
 
    if (Class.CastTo(swapmag1, entity1) && Class.CastTo(swapmag2, entity2))
    {
      Weapon_Base parentWpn;
 
      if (Class.CastTo(parentWpn, swapmag1.GetHierarchyParent()))
      {
        skipSwap = true;
        if (m_player.GetWeaponManager().CanSwapMagazine(parentWpn, swapmag2))
          flags = flags | InventoryCombinationFlags.SWAP;
      }
 
      if (Class.CastTo(parentWpn, swapmag2.GetHierarchyParent()))
      {
        skipSwap = true;
        if (m_player.GetWeaponManager().CanSwapMagazine(parentWpn, swapmag1))
          flags = flags | InventoryCombinationFlags.SWAP;
 
      }
    }
 
    if (!skipSwap)
    {
      if (entity1 == m_player.GetHumanInventory().GetEntityInHands()) flags = flags | InventoryCombinationFlags.TAKE_TO_HANDS;
      else if (GameInventory.CanSwapEntitiesEx(entity1, entity2))
      {
        if (!entity1.IsInherited(ZombieBase) && !entity1.IsInherited(Car))
          flags = flags | InventoryCombinationFlags.SWAP;
      }
    }
 
    if (entity1.IsInherited(ItemBase) && entity2.IsInherited(ItemBase))
    {
      ItemBase ent1 = ItemBase.Cast(entity1);
      if (ent1.CanBeCombined(ItemBase.Cast(entity2))) flags = flags | InventoryCombinationFlags.COMBINE_QUANTITY2;
    }
 
    else if (entity1.GetInventory().CanAddAttachment(entity2))
    {
      if (!entity1.IsInherited(ZombieBase) && !entity1.IsInherited(Car) && !entity2.IsInherited(ZombieBase) && !entity2.IsInherited(Car))
        flags = flags | InventoryCombinationFlags.ADD_AS_ATTACHMENT;
    }
    if (!entity1.GetInventory().HasEntityInInventory(entity2) && entity1.GetInventory().CanAddEntityInCargo(entity2, entity2.GetInventory().GetFlipCargo())) flags = flags | InventoryCombinationFlags.ADD_AS_CARGO;
 
    if (entity1 == m_player.GetHumanInventory().GetEntityInHands() || entity2 == m_player.GetHumanInventory().GetEntityInHands())
    {
      ActionManagerClient amc;
      Class.CastTo(amc, m_player.GetActionManager());
      if (entity1 == m_player.GetHumanInventory().GetEntityInHands())
      {
        if (amc.CanSetActionFromInventory(ItemBase.Cast(entity1), ItemBase.Cast(entity2)))
          flags = flags | InventoryCombinationFlags.SET_ACTION;
      }
      else
      {
        if (amc.CanSetActionFromInventory(ItemBase.Cast(entity2), ItemBase.Cast(entity1)))
          flags = flags | InventoryCombinationFlags.SET_ACTION;
      }
    }
 
    if (GetRecipeCount(true, entity1, entity2) > 0)
      flags = flags | InventoryCombinationFlags.RECIPE_ANYWHERE;
    return flags;
  }
 
  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()));
  }
 
  void RemoveItem()
  {
    m_Entity = null;
    m_CollapsibleHeader.ShowCollapseButtons(false, true);
  }
 
  void DestroyAtt()
  {
    if (m_Atts)
    {
      m_Body.RemoveItem(m_Atts.GetWrapper());
      delete m_Atts;
 
      if (m_Entity)
      {
        m_Entity.GetOnItemAttached().Remove(AttachmentAdded);
        m_Entity.GetOnItemDetached().Remove(AttachmentRemoved);
      }
    }
 
    if (m_AttachmentAttachmentsContainers)
    {
      foreach (EntityAI ent, AttachmentsWrapper att : m_AttachmentAttachmentsContainers)
      {
        m_Body.RemoveItem(att);
        m_AttachmentAttachments.Remove(ent);
        delete att;
      }
    }
 
    m_AttachmentAttachmentsContainers.Clear();
    Refresh();
    m_Parent.Refresh();
    RecomputeOpenedContainers();
  }
 
  override void UnfocusGrid()
  {
    if (m_Atts)
      m_Atts.UnfocusAll();
 
    if (m_CargoGrid)
      m_CargoGrid.UnfocusAll();
 
    if (m_AttachmentCargos)
    {
      foreach (EntityAI e1, CargoContainer cargo : m_AttachmentCargos)
        cargo.UnfocusAll();
 
    }
 
    if (m_AttachmentCargos)
    {
      foreach (EntityAI e2, Attachments att : m_AttachmentAttachments)
        att.UnfocusAll();
    }
  }
 
  override void UnfocusAll()
  {
    UnfocusGrid();
  }
 
  void DestroyCargo()
  {
    if (m_CargoGrid)
    {
      m_Body.RemoveItem(m_CargoGrid);
      delete m_CargoGrid;
    }
 
    if (m_AttachmentCargos)
    {
      foreach (CargoContainer cargo : m_AttachmentCargos)
      {
        m_Body.RemoveItem(cargo);
        delete cargo;
      }
    }
 
    m_AttachmentCargos.Clear();
    Refresh();
    m_Parent.Refresh();
    RecomputeOpenedContainers();
  }
 
  void DropReceived(Widget w, int x, int y, CargoContainer cargo)
  {
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    EntityAI item_in_hands = player.GetHumanInventory().GetEntityInHands();
 
    EntityAI item = GetItemPreviewItem(w);
    if (!item)
      return;
 
    int idx = 0;
    int c_x, c_y;
 
    EntityAI target_entity;
    CargoBase target_cargo;
 
    if (cargo == m_CargoGrid)
    {
      target_entity = m_Entity;
      target_cargo = m_Entity.GetInventory().GetCargo();
#ifdef PLATFORM_CONSOLE
      if (m_CargoGrid.HasItem(item))
        return;
#endif
    }
    else
    {
      target_entity = m_AttachmentCargos.GetKeyByValue(cargo);
      if (target_entity)
      {
        target_cargo = target_entity.GetInventory().GetCargo();
#ifdef PLATFORM_CONSOLE
        if (cargo.HasItem(item))
          return;
#endif
      }
      else
        return;
    }
 
    if (target_cargo && target_entity)
    {
      c_x = target_cargo.GetHeight();
      c_y = target_cargo.GetWidth();
    }
    else
      return;
 
    InventoryLocation dst = new InventoryLocation;
#ifdef PLATFORM_CONSOLE
    x = 0;
    y = target_cargo.GetItemCount();
    target_entity.GetInventory().FindFreeLocationFor(item, FindInventoryLocationType.CARGO, dst);
#else
    dst.SetCargoAuto(target_cargo, item, x, y, item.GetInventory().GetFlipCargo());
#endif
 
    InventoryLocation src = new InventoryLocation;
    item.GetInventory().GetCurrentInventoryLocation(src);
    if (src.CompareLocationOnly(dst) && src.GetFlip() == dst.GetFlip())
      return;
 
#ifdef PLATFORM_CONSOLE
    if (dst.IsValid() && target_entity.GetInventory().LocationCanAddEntity(dst))
#else
    if (c_x > x && c_y > y && target_entity.GetInventory().LocationCanAddEntity(dst))
#endif
    {
      SplitItemUtils.TakeOrSplitToInventoryLocation(player, dst);
 
      Icon icon = cargo.GetIcon(item);
 
      if (icon)
      {
        if (w && w.FindAnyWidget("Cursor"))
          w.FindAnyWidget("Cursor").SetColor(ColorManager.BASE_COLOR);
        icon.Refresh();
        Refresh();
      }
    }
    ItemManager.GetInstance().HideDropzones();
    ItemManager.GetInstance().SetIsDragging(false);
  }
 
  bool DraggingOverGrid(Widget w, int x, int y, Widget reciever, CargoContainer cargo)
  {
    EntityAI item_in_hands = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
    if (w == null)
      return false;
    EntityAI item = GetItemPreviewItem(w);
    if (!item || !item_in_hands)
      return false;
 
    int color;
    int idx = 0;
    int c_x, c_y;
 
    if (item_in_hands.GetInventory().GetCargo())
    {
      c_x = item_in_hands.GetInventory().GetCargo().GetHeight();
      c_y = item_in_hands.GetInventory().GetCargo().GetWidth();
    }
 
    if (c_x > x && c_y > y && item_in_hands.GetInventory().CanAddEntityInCargoEx(item, 0, x, y, item.GetInventory().GetFlipCargo()))
    {
      ItemManager.GetInstance().HideDropzones();
      ItemManager.GetInstance().GetCenterDropzone().SetAlpha(1);
      color = ColorManager.GREEN_COLOR;
    }
    else
    {
      color = ColorManager.RED_COLOR;
      ItemManager.GetInstance().ShowSourceDropzone(item);
    }
 
    if (w.FindAnyWidget("Cursor"))
      w.FindAnyWidget("Cursor").SetColor(color);
    else
    {
      string name = w.GetName();
      name.Replace("PanelWidget", "Cursor");
      w.FindAnyWidget(name).SetColor(color);
    }
 
    return true;
  }
 
  void TakeAsAttachment(Widget w, Widget receiver)
  {
    EntityAI receiver_item;
    EntityAI slot_owner;
    int slot_id = -1;
 
    SlotsIcon slots_icon;
    receiver.GetUserData(slots_icon);
    if (slots_icon)
    {
      receiver_item = slots_icon.GetEntity();
      slot_id = slots_icon.GetSlotID();
      slot_owner = slots_icon.GetSlotParent();
    }
 
    EntityAI item = GetItemPreviewItem(w);
    if (!item)
      return;
 
    ItemBase item_base = ItemBase.Cast(item);
    float stack_max = item_base.GetTargetQuantityMax(slot_id);
 
    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 (player.GetWeaponManager().CanSwapMagazine(wpn, mag))
        player.GetWeaponManager().SwapMagazine(mag);
    }
    else if (receiver_item)
    {
      if (receiver_item != item)
      {
        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(item, receiver_item);
        }
      }
    }
    else if (slot_owner && slot_owner.GetInventory().CanAddAttachmentEx(item, slot_id))
    {
      if (stack_max == 0 || stack_max >= item_base.GetQuantity())
        player.PredictiveTakeEntityToTargetAttachmentEx(slot_owner, item, slot_id);
      else if (stack_max != 0 && stack_max < item_base.GetQuantity())
        item_base.SplitIntoStackMaxClient(m_Entity, slot_id);
    }
    else if (slot_owner && slot_owner.GetInventory().CanAddAttachment(item))
    {
      if (stack_max == 0 || stack_max >= item_base.GetQuantity())
        player.PredictiveTakeEntityToTargetAttachment(slot_owner, item);
      else if (stack_max != 0 && stack_max < item_base.GetQuantity())
        item_base.SplitIntoStackMaxClient(m_Entity, -1);
    }
    else if (m_Entity.GetInventory().CanAddAttachment(item))
    {
      if (stack_max == 0 || stack_max >= item_base.GetQuantity())
        player.PredictiveTakeEntityToTargetAttachment(m_Entity, item);
      else if (stack_max != 0 && stack_max < item_base.GetQuantity())
        item_base.SplitIntoStackMaxClient(m_Entity, -1);
    }
    else if ((m_Entity.GetInventory().CanAddEntityInCargo(item, item.GetInventory().GetFlipCargo()) && (!player.GetInventory().HasEntityInInventory(item) || !m_Entity.GetInventory().HasEntityInCargo(item))) || player.GetHumanInventory().HasEntityInHands(item))
      SplitItemUtils.TakeOrSplitToInventory(PlayerBase.Cast(GetGame().GetPlayer()), m_Entity, item);
    /*else if( !player.GetInventory().HasEntityInInventory( item ) || !m_Entity.GetInventory().HasEntityInCargo( item ) )
      {
      SplitItemUtils.TakeOrSplitToInventory( PlayerBase.Cast( GetGame().GetPlayer() ), m_Entity, item );
      }*/
 
    ItemManager.GetInstance().HideDropzones();
    ItemManager.GetInstance().SetIsDragging(false);
  }
 
  void ShowAtt(EntityAI entity)
  {
    ResetContainer();
    m_StaticCargoCount = 0;
    m_Entity = entity;
    m_ActiveIndex = 0;
    if (entity.GetSlotsCountCorrect() > 0)
    {
      m_Atts = new Attachments(this, entity);
      m_Atts.InitAttachmentGrid(1);
      m_AttachmentSlotsSorted = m_Atts.GetSlotsSorted();
      m_StaticAttCount = m_Atts.GetAttachmentHeight();
      m_Entity.GetOnItemAttached().Insert(AttachmentAdded);
      m_Entity.GetOnItemDetached().Insert(AttachmentRemoved);
    }
    else
      m_StaticAttCount = 0;
 
    if (entity.GetInventory().GetCargo())
    {
      m_CargoGrid = new CargoContainer(this, false);
      m_CargoGrid.SetEntity(entity);
      m_CargoGrid.GetRootWidget().SetSort(1);
      Insert(m_CargoGrid);
      m_StaticCargoCount++;
    }
 
    if (m_AttachmentSlotsSorted)
    {
      foreach (int slot_id : m_AttachmentSlotsSorted)
      {
        EntityAI item = m_Entity.GetInventory().FindAttachment(slot_id);
        if (item)
          AttachmentAdded(item, InventorySlots.GetSlotName(slot_id), m_Entity);
      }
    }
 
    if (m_CargoGrid)
    {
      bool hideCargo = m_Entity.GetInventory().IsInventoryLockedForLockType(HIDE_INV_FROM_SCRIPT) || !m_Entity.CanDisplayCargo() || m_ForcedHide;
      if (m_CargoGrid.IsVisible() && hideCargo)
        HideCargo();
      else if (!m_CargoGrid.IsVisible() && !hideCargo)
        ShowCargo();
    }
 
    m_CollapsibleHeader.ShowCollapseButtons(false);
    //m_CollapsibleHeader.ShowCollapseButtons( m_Atts || m_CargoGrid, m_Atts || m_CargoGrid );
    RecomputeOpenedContainers();
    Refresh();
    m_Parent.Refresh();
  }
 
  void RefreshHands()
  {
    for (int i = 0; i < m_Body.Count(); i++)
      m_Body.Get(i).OnShow();
    Refresh();
    m_Parent.Refresh();
  }
 
  void AttachmentAdded(EntityAI item, string slot, EntityAI parent)
  {
    int slot_id = InventorySlots.GetSlotIdFromString(slot);
    int sort = -1;
    Attachments att_cont = null;
    CargoContainer cont = null;
 
    if (item.GetInventory().GetAttachmentSlotsCount() > 0)
    {
      att_cont = new Attachments(this, item);
      sort = (m_AttachmentSlotsSorted.Find(slot_id) * 2) + SORT_ATTACHMENTS_NEXT_OFFSET;
      att_cont.InitAttachmentGrid(sort);
 
      m_AttachmentAttachments.Insert(item, att_cont);
      m_AttachmentAttachmentsContainers.Insert(item, att_cont.GetWrapper());
 
      att_cont.UpdateInterval();
      if (m_Parent)
        m_Parent.Refresh();
      Inventory.GetInstance().UpdateConsoleToolbar();
    }
 
    if (item.GetInventory().GetCargo())
    {
      cont = new CargoContainer(this, true);
      sort = (m_AttachmentSlotsSorted.Find(slot_id) * 2) + SORT_CARGO_NEXT_OFFSET; //m_AttachmentSlotsSorted.Find( slot_id ) + 50
      cont.GetRootWidget().SetSort(sort);
      cont.SetEntity(item);
 
      Insert(cont, -1);
 
      m_AttachmentCargos.Insert(item, cont);
      if (m_Parent)
        m_Parent.Refresh();
      Inventory.GetInstance().UpdateConsoleToolbar();
    }
 
    if (att_cont)
    {
      att_cont.ShowFalseAttachmentsHeader(true);
      if (cont)
      {
        cont.ShowFalseCargoHeader(false);
        cont.UpdateSize();
        cont.SetAlternateFalseTextHeaderWidget(att_cont.GetFalseHeaderTextWidget());
      }
    }
    else if (cont)
    {
      cont.SetAlternateFalseTextHeaderWidget(null); //just to be safe..
    }
 
    RecomputeOpenedContainers();
  }
 
  void AttachmentRemoved(EntityAI item, string slot, EntityAI parent)
  {
    int slot_id = InventorySlots.GetSlotIdFromString(slot);
 
    CargoContainer old_cont = m_AttachmentCargos.Get(item);
    if (old_cont)
    {
      m_Body.RemoveItem(old_cont);
      m_AttachmentCargos.Remove(item);
      delete old_cont;
      if (m_Parent)
        m_Parent.Refresh();
      Inventory.GetInstance().UpdateConsoleToolbar();
    }
 
    AttachmentsWrapper old_att_cont = m_AttachmentAttachmentsContainers.Get(item);
    if (old_att_cont)
    {
      m_AttachmentAttachmentsContainers.Remove(item);
      m_AttachmentAttachments.Remove(item);
      m_Body.RemoveItem(old_att_cont);
      delete old_att_cont;
      if (m_Parent)
        m_Parent.Refresh();
      Inventory.GetInstance().UpdateConsoleToolbar();
    }
    RecomputeOpenedContainers();
  }
 
  override void UpdateInterval()
  {
    super.UpdateInterval();
 
    if (m_Entity)
    {
      if (m_CargoGrid)
      {
        bool hideCargo = m_Entity.GetInventory().IsInventoryLockedForLockType(HIDE_INV_FROM_SCRIPT) || !m_Entity.CanDisplayCargo() || m_ForcedHide;
        if (m_CargoGrid.IsVisible() && hideCargo)
          HideCargo();
        else if (!m_CargoGrid.IsVisible() && !hideCargo)
          ShowCargo();
 
        m_CargoGrid.UpdateInterval();
      }
 
      if (m_Atts)
        m_Atts.UpdateInterval();
 
      for (int i = 0; i < m_AttachmentCargos.Count(); i++)
        m_AttachmentCargos.GetElement(i).UpdateInterval();
    }
 
    ElectricityIcon();
    m_CollapsibleHeader.UpdateInterval();
  }
 
  override void SetLayoutName()
  {
    m_LayoutName = WidgetLayoutName.ClosableContainer;
  }
 
  override void OnShow()
  {
    super.OnShow();
 
    for (int i = 0; i < m_Body.Count(); i++)
      m_Body.Get(i).OnShow();
  }
 
  void MouseClick2(Widget w, int x, int y, int button)
  {
    string name = w.GetName();
    name.Replace("PanelWidget", "Render");
    ItemPreviewWidget itemPreview = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
 
    if (itemPreview)
    {
      ItemBase selectedItem = ItemBase.Cast(itemPreview.GetItem());
 
      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 (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);
            }
          }
 
          break;
        }
      }
    }
  }
 
  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);
 
      ItemBase item = ItemBase.Cast(iw.GetItem());
      if (item)
      {
        PlayerBase controlledPlayer = PlayerBase.Cast(GetGame().GetPlayer());
        EntityAI itemInHands = controlledPlayer.GetHumanInventory().GetEntityInHands();
 
        if (!item.GetInventory().CanRemoveEntity())
          return;
 
        if (controlledPlayer.GetInventory().HasEntityInInventory(item) && controlledPlayer.GetHumanInventory().CanAddEntityInHands(item))
          controlledPlayer.PredictiveTakeEntityToHands(item);
        else
        {
          if (controlledPlayer.GetInventory().CanAddEntityToInventory(item) && controlledPlayer.GetHumanInventory().CanRemoveEntityInHands())
            controlledPlayer.PredictiveTakeEntityToInventory(FindInventoryLocationType.ANY, item);
          else
          {
            if (controlledPlayer.GetHumanInventory().CanAddEntityInHands(item))
              controlledPlayer.PredictiveTakeEntityToHands(item);
          }
        }
 
        HideOwnedTooltip();
 
        name = w.GetName();
        name.Replace("PanelWidget", "Temperature");
        w.FindAnyWidget(name).Show(false);
      }
    }
  }
 
  void DraggingOverHeader2(Widget w, int x, int y, Widget receiver)
  {
    DraggingOverHeader(w, x, y, receiver);
  }
 
  void ElectricityIcon()
  {
    EntityAI item_in_hands = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
    if (item_in_hands && item_in_hands.GetCompEM())
    {
      if (GetRootWidget().FindAnyWidget("electricity"))
      {
        bool show_electricity_icon = item_in_hands.GetCompEM().HasElectricityIcon();
        GetRootWidget().FindAnyWidget("electricity").Show(show_electricity_icon);
      }
 
      if (GetRootWidget().FindAnyWidget("electricity_can_work"))
      {
        bool show_electricity_can_work_icon = item_in_hands.GetCompEM().CanWork() && !item_in_hands.IsRuined();
        GetRootWidget().FindAnyWidget("electricity_can_work").Show(show_electricity_can_work_icon);
      }
    }
    else
      GetRootWidget().FindAnyWidget("electricity").Show(false);
  }
 
  void CollapseButtonOnMouseButtonDown(Widget w)
  {
    int i;
    if (!m_Hidden)
    {
      for (i = 0; i < m_Body.Count(); i++)
        m_Body.Get(i).OnHide();
      m_Hidden = true;
    }
    else
    {
      for (i = 0; i < m_Body.Count(); i++)
        m_Body.Get(i).OnShow();
      m_Hidden = false;
    }
 
    w.FindAnyWidget("opened").Show(m_Hidden);
    w.FindAnyWidget("closed").Show(!m_Hidden);
 
    m_Parent.Refresh();
  }
 
  void HideCargo()
  {
    if (m_CargoGrid)
    {
      m_CargoGrid.OnHide();
      RecomputeOpenedContainers();
    }
  }
 
  void ShowCargo()
  {
    if (m_CargoGrid)
    {
      m_CargoGrid.OnShow();
      RecomputeOpenedContainers();
    }
  }
}