HandsContainer Class Reference

Inheritance diagram for HandsContainer:

Collaboration diagram for HandsContainer:

Protected Member Functions
void	HandsContainer (LayoutHolder parent)
void	~HandsContainer ()
void	ResetContainer ()
override Header	GetHeader ()
override bool	IsLastIndex ()
void	SetFocusToIndex ()
void	ScrollToActiveContainer (Container active_container)
override void	Insert (LayoutHolder container, int pos=-1, bool immedUpdate=true)
override bool	TransferItem ()
override bool	SplitItem ()
override bool	EquipItem ()
override void	SetActive (bool active)
override void	SetLastActive ()
override void	Refresh ()
override bool	IsItemActive ()
override bool	IsItemWithQuantityActive ()
override bool	IsEmpty ()
override bool	TransferItemToVicinity ()
override bool	InspectItem ()
override bool	OnSelectButton ()
EntityAI	GetItemPreviewItem (Widget w)
override void	DraggingOverHeader (Widget w, int x, int y, Widget receiver)
void	OnDropReceivedFromHeader2 (Widget w, int x, int y, Widget receiver)
void	OnPerformCombination (int combinationFlags)
void	ShowActionMenuCombine (EntityAI entity1, EntityAI entity2, int combinationFlags)
override void	OnDropReceivedFromHeader (Widget w, int x, int y, Widget receiver)
int	GetCombinationFlags (EntityAI entity1, EntityAI entity2)
int	GetRecipeCount (bool recipe_anywhere, EntityAI entity1, EntityAI entity2)
void	RemoveItem ()
void	DestroyAtt ()
override void	UnfocusGrid ()
override void	UnfocusAll ()
void	DestroyCargo ()
void	DropReceived (Widget w, int x, int y, CargoContainer cargo)
bool	DraggingOverGrid (Widget w, int x, int y, Widget reciever, CargoContainer cargo)
void	TakeAsAttachment (Widget w, Widget receiver)
void	ShowAtt (EntityAI entity)
void	RefreshHands ()
void	AttachmentAdded (EntityAI item, string slot, EntityAI parent)
void	AttachmentRemoved (EntityAI item, string slot, EntityAI parent)
override void	UpdateInterval ()
override void	SetLayoutName ()
override void	OnShow ()
void	MouseClick2 (Widget w, int x, int y, int button)
void	DoubleClick (Widget w, int x, int y, int button)
void	DraggingOverHeader2 (Widget w, int x, int y, Widget receiver)
void	ElectricityIcon ()
void	CollapseButtonOnMouseButtonDown (Widget w)
void	HideCargo ()
void	ShowCargo ()

Protected Attributes
bool	m_Hidden
ref HandsHeader	m_CollapsibleHeader
ref HandsPreview	m_HandsPreview
ref Attachments	m_Atts
ref CargoContainer	m_CargoGrid
ref map< EntityAI, ref CargoContainer >	m_AttachmentCargos
ref map< EntityAI, AttachmentsWrapper >	m_AttachmentAttachmentsContainers
ref map< EntityAI, ref Attachments >	m_AttachmentAttachments
ref array< int >	m_AttachmentSlotsSorted
int	m_StaticAttCount = 0
int	m_StaticCargoCount = 0
ScrollWidget	m_ScrollWidget

Additional Inherited Members
Private Member Functions inherited from Container
void	CargoContainer (LayoutHolder parent, bool is_attachment=false)
void	~CargoContainer ()
int	GetCargoIndex ()
void	AddedToCargoEx (EntityAI item, bool refresh=true)
void	AddedToCargo (EntityAI item)
void	RemovedFromCargo (EntityAI item)
void	MovedInCargo (EntityAI item)
void	SetLock (EntityAI item)
void	ReleaseLock (EntityAI item)
override void	SetLayoutName ()
void	SetEntity (EntityAI item, int cargo_index=0, bool immedUpdate=true)
EntityAI	GetEntity ()
void	UpdateHeaderText ()
void	InitGridHeight ()
void	UpdateSize ()
float	GetIconSize ()
float	GetSpaceSize ()
int	GetCargoCapacity ()
int	GetMaxCargoCapacity ()
Icon	GetIcon (EntityAI item)
Icon	GetIcon (int index)
Icon	GetFocusedIcon ()
override float	GetFocusedContainerHeight (bool contents=false)
override float	GetFocusedContainerYPos (bool contents=false)
override float	GetFocusedContainerYScreenPos (bool contents=false)
void	UpdateSelection ()
void	UpdateRowVisibility (int count)
override void	Refresh ()
void	RefreshImpl ()
override void	UpdateInterval ()
Icon	InitIconEx (Icon icon, EntityAI item, int pos_x, int pos_y, bool refresh=true)
Icon	InitIcon (Icon icon, EntityAI item, int pos_x, int pos_y)
bool	HasItem (EntityAI item)
override bool	TransferItemToVicinity ()
override void	SetDefaultFocus (bool while_micromanagment_mode=false)
override void	SetLastFocus ()
override void	Unfocus ()
override void	UnfocusAll ()
override void	SetNextActive ()
override void	SetPreviousActive (bool force=false)
override void	SetNextRightActive ()
override void	SetNextLeftActive ()
override EntityAI	GetFocusedItem ()
override void	SetLastActive ()
override void	SetActive (bool active)
override bool	IsItemActive ()
override bool	IsItemWithQuantityActive ()
override bool	IsEmpty ()
int	GetRecipeCount (bool recipe_anywhere, ItemBase entity1, ItemBase entity2, PlayerBase player)
override bool	CanCombineAmmo ()
override bool	TransferItem ()
override bool	SplitItem ()
override bool	EquipItem ()
override bool	SelectItem ()
override bool	Select ()
override bool	Combine ()
void	ShowFalseCargoHeader (bool show)
void	SetAlternateFalseTextHeaderWidget (TextWidget w)
void	ClosableContainer (LayoutHolder parent, int sort=-1)
override bool	IsDisplayable ()
override void	UpdateRadialIcon ()
void	SetOpenState (bool state)
override Header	GetHeader ()
override void	Open ()
override void	Close ()
override void	SetLayoutName ()
override void	OnShow ()
override LayoutHolder	Get (int x)
override void	Refresh ()
void	CloseButtonOnMouseButtonDown ()
override float	GetFocusedContainerHeight (bool contents=false)
override float	GetFocusedContainerYPos (bool contents=false)
override float	GetFocusedContainerYScreenPos (bool contents=false)
void	MoveContainerUp (Widget cont)
void	MoveContainerDown (Widget cont)
override void	CheckHeaderDragability ()
Private Attributes inherited from Container
const int	ROWS_NUMBER_XBOX = 5
CargoBase	m_Cargo
int	m_CargoIndex = -1
int	m_FocusedItemPosition = -1
ref array< ref CargoContainerRow >	m_Rows
ref array< ref Icon >	m_Icons
ref map< EntityAI, ref Param3< ref Icon, int, int > >	m_ShowedItemPositions
ref map< EntityAI, ref Param3< ref Icon, int, int > >	m_ShowedLockPositions
float	m_IconSize
float	m_SpaceSize
bool	m_IsAttachment
TextWidget	m_FalseHeaderTextWidget
TextWidget	m_AlternateFalseHeaderTextWidget
Widget	m_CargoHeader
Widget	m_CargoContainer
Widget	m_ItemsContainer
ref SizeToChild	m_Resizer1
ref SizeToChild	m_Resizer2
ref Timer	m_ResizeTimer
ref ClosableHeader	m_ClosableHeader
bool	m_LockCargo

Detailed Description

Definition at line 1 of file HandsContainer.c.

Constructor & Destructor Documentation

HandsContainer()

void HandsContainer::HandsContainer ( LayoutHolder parent )

inlineprotected

Definition at line 20 of file HandsContainer.c.

  {
    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();
  }

References GetGame(), ItemManager::GetInstance(), GetPlayer(), m_AttachmentAttachments, m_AttachmentAttachmentsContainers, m_AttachmentCargos, m_CollapsibleHeader, m_HandsPreview, m_RootWidget, and m_ScrollWidget.

~HandsContainer()

void HandsContainer::~HandsContainer ( )

inlineprotected

Definition at line 43 of file HandsContainer.c.

  {
    if (m_Entity)
    {
      m_Entity.GetOnItemAttached().Remove(AttachmentAdded);
      m_Entity.GetOnItemDetached().Remove(AttachmentRemoved);
    }
 
    m_AttachmentCargos.Clear();
    m_AttachmentAttachmentsContainers.Clear();
    m_AttachmentAttachments.Clear();
  }

References AttachmentAdded(), AttachmentRemoved(), m_AttachmentAttachments, m_AttachmentAttachmentsContainers, m_AttachmentCargos, and m_Entity.

Member Function Documentation

AttachmentAdded()

void HandsContainer::AttachmentAdded ( EntityAI item, string slot, EntityAI parent )

inlineprotected

Definition at line 1144 of file HandsContainer.c.

  {
    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();
  }

References Container::CargoContainer(), InventorySlots::GetSlotIdFromString(), Insert(), Inventory(), m_AttachmentAttachments, m_AttachmentAttachmentsContainers, m_AttachmentCargos, m_AttachmentSlotsSorted, and m_Parent.

Referenced by DestroyAtt(), ShowAtt(), and ~HandsContainer().

AttachmentRemoved()

void HandsContainer::AttachmentRemoved ( EntityAI item, string slot, EntityAI parent )

inlineprotected

Definition at line 1199 of file HandsContainer.c.

  {
    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();
  }

References Container::CargoContainer(), InventorySlots::GetSlotIdFromString(), Inventory(), m_AttachmentAttachments, m_AttachmentAttachmentsContainers, m_AttachmentCargos, and m_Parent.

Referenced by DestroyAtt(), ShowAtt(), and ~HandsContainer().

CollapseButtonOnMouseButtonDown()

void HandsContainer::CollapseButtonOnMouseButtonDown ( Widget w )

inlineprotected

Definition at line 1391 of file HandsContainer.c.

  {
    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();
  }

References m_Hidden, and m_Parent.

DestroyAtt()

void HandsContainer::DestroyAtt ( )

inlineprotected

Definition at line 795 of file HandsContainer.c.

  {
    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();
  }

References AttachmentAdded(), AttachmentRemoved(), m_AttachmentAttachments, m_AttachmentAttachmentsContainers, m_Atts, m_Entity, m_Parent, and Refresh().

DestroyCargo()

void HandsContainer::DestroyCargo ( )

inlineprotected

Definition at line 852 of file HandsContainer.c.

  {
    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();
  }

References Container::CargoContainer(), m_AttachmentCargos, m_CargoGrid, m_Parent, and Refresh().

DoubleClick()

void HandsContainer::DoubleClick ( Widget w, int x, int y, int button )

inlineprotected

Definition at line 1319 of file HandsContainer.c.

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

References g_Game, GetGame(), GetPlayer(), and name.

DraggingOverGrid()

bool HandsContainer::DraggingOverGrid ( Widget w, int x, int y, Widget reciever, CargoContainer cargo )

inlineprotected

Definition at line 958 of file HandsContainer.c.

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

References GetGame(), ItemManager::GetInstance(), GetItemPreviewItem(), ColorManager::GREEN_COLOR, name, ColorManager::RED_COLOR, x, and y.

DraggingOverHeader()

override void HandsContainer::DraggingOverHeader ( Widget w, int x, int y, Widget receiver )

inlineprotected

Definition at line 422 of file HandsContainer.c.

  {
    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);
      //}
    }
  }

References GameInventory::CanSwapEntitiesEx(), ColorManager::COMBINE_COLOR, GetGame(), ColorManager::GetInstance(), ItemManager::GetInstance(), GetPlayer(), ColorManager::GREEN_COLOR, m_Entity, name, ColorManager::RED_COLOR, and ColorManager::SWAP_COLOR.

Referenced by DraggingOverHeader2().

DraggingOverHeader2()

void HandsContainer::DraggingOverHeader2 ( Widget w, int x, int y, Widget receiver )

inlineprotected

Definition at line 1365 of file HandsContainer.c.

  {
    DraggingOverHeader(w, x, y, receiver);
  }

References DraggingOverHeader(), x, and y.

DropReceived()

void HandsContainer::DropReceived ( Widget w, int x, int y, CargoContainer cargo )

inlineprotected

Definition at line 875 of file HandsContainer.c.

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

References ColorManager::BASE_COLOR, GetGame(), ItemManager::GetInstance(), GetItemPreviewItem(), GetPlayer(), m_AttachmentCargos, m_CargoGrid, m_Entity, Refresh(), SplitItemUtils::TakeOrSplitToInventoryLocation(), x, and y.

ElectricityIcon()

void HandsContainer::ElectricityIcon ( )

inlineprotected

Definition at line 1370 of file HandsContainer.c.

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

References FindAnyWidget(), and GetGame().

Referenced by UpdateInterval().

EquipItem()

override bool HandsContainer::EquipItem ( )

inlineprotected

Definition at line 227 of file HandsContainer.c.

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

References GetGame(), and GetPlayer().

GetCombinationFlags()

int HandsContainer::GetCombinationFlags ( EntityAI entity1, EntityAI entity2 )

inlineprotected

Definition at line 707 of file HandsContainer.c.

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

References InventoryCombinationFlags::ADD_AS_ATTACHMENT, InventoryCombinationFlags::ADD_AS_CARGO, GameInventory::CanSwapEntitiesEx(), WeaponManager::CanSwapMagazine(), Class::CastTo(), InventoryCombinationFlags::COMBINE_QUANTITY2, GetGame(), GetPlayer(), GetRecipeCount(), DayZPlayer::GetWeaponManager(), m_player, InventoryCombinationFlags::RECIPE_ANYWHERE, InventoryCombinationFlags::SET_ACTION, InventoryCombinationFlags::SWAP, and InventoryCombinationFlags::TAKE_TO_HANDS.

GetHeader()

override Header HandsContainer::GetHeader ( )

inlineprotected

Definition at line 62 of file HandsContainer.c.

  {
    return m_CollapsibleHeader;
  }

References m_CollapsibleHeader.

Referenced by HandsPreview::CreateNewIcon().

GetItemPreviewItem()

EntityAI HandsContainer::GetItemPreviewItem ( Widget w )

inlineprotected

Definition at line 403 of file HandsContainer.c.

  {
    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();
  }

References name.

Referenced by DraggingOverGrid(), DropReceived(), and TakeAsAttachment().

GetRecipeCount()

int HandsContainer::GetRecipeCount ( bool recipe_anywhere, EntityAI entity1, EntityAI entity2 )

inlineprotected

Definition at line 783 of file HandsContainer.c.

  {
    PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(GetPlugin(PluginRecipesManager));
    return plugin_recipes_manager.GetValidRecipes(ItemBase.Cast(entity1), ItemBase.Cast(entity2), null, PlayerBase.Cast(GetGame().GetPlayer()));
  }

References GetGame(), GetPlayer(), and GetPlugin().

Referenced by GetCombinationFlags().

HideCargo()

void HandsContainer::HideCargo ( )

inlineprotected

Definition at line 1413 of file HandsContainer.c.

  {
    if (m_CargoGrid)
    {
      m_CargoGrid.OnHide();
      RecomputeOpenedContainers();
    }
  }

References m_CargoGrid.

Referenced by ShowAtt(), and UpdateInterval().

Insert()

override void HandsContainer::Insert ( LayoutHolder container, int pos = -1, bool immedUpdate = true )

inlineprotected

Definition at line 180 of file HandsContainer.c.

  {
    super.Insert(container, pos, immedUpdate);
  }

Referenced by AttachmentAdded(), and ShowAtt().

InspectItem()

override bool HandsContainer::InspectItem ( )

inlineprotected

Definition at line 357 of file HandsContainer.c.

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

References GetGame(), GetPlayer(), and InspectItem().

Referenced by InspectItem(), and MouseClick2().

IsEmpty()

override bool HandsContainer::IsEmpty ( )

inlineprotected

Definition at line 326 of file HandsContainer.c.

  {
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    return player.GetHumanInventory().GetEntityInHands() == null;
  }

References GetGame(), and GetPlayer().

Referenced by IsItemActive(), and IsItemWithQuantityActive().

IsItemActive()

override bool HandsContainer::IsItemActive ( )

inlineprotected

Definition at line 308 of file HandsContainer.c.

  {
    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()));
  }

References GetGame(), GetPlayer(), QuantityConversions::HasItemQuantity(), and IsEmpty().

IsItemWithQuantityActive()

override bool HandsContainer::IsItemWithQuantityActive ( )

inlineprotected

Definition at line 317 of file HandsContainer.c.

  {
    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();
  }

References GetGame(), GetPlayer(), QuantityConversions::HasItemQuantity(), and IsEmpty().

IsLastIndex()

override bool HandsContainer::IsLastIndex ( )

inlineprotected

Definition at line 67 of file HandsContainer.c.

  {
    return m_ActiveIndex == m_OpenedContainers.Count() - 1;
  }

MouseClick2()

void HandsContainer::MouseClick2 ( Widget w, int x, int y, int button )

inlineprotected

Definition at line 1269 of file HandsContainer.c.

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

References g_Game, GetGame(), ItemManager::GetInstance(), GetPlayer(), InspectItem(), and name.

OnDropReceivedFromHeader()

override void HandsContainer::OnDropReceivedFromHeader ( Widget w, int x, int y, Widget receiver )

inlineprotected

Definition at line 702 of file HandsContainer.c.

  {
    TakeAsAttachment(w, receiver);
  }

References TakeAsAttachment().

OnDropReceivedFromHeader2()

void HandsContainer::OnDropReceivedFromHeader2 ( Widget w, int x, int y, Widget receiver )

inlineprotected

Definition at line 554 of file HandsContainer.c.

  {
    TakeAsAttachment(w, receiver);
  }

References TakeAsAttachment().

OnPerformCombination()

void HandsContainer::OnPerformCombination ( int combinationFlags )

inlineprotected

Definition at line 559 of file HandsContainer.c.

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

References InventoryCombinationFlags::ADD_AS_ATTACHMENT, InventoryCombinationFlags::ADD_AS_CARGO, WeaponManager::AttachMagazine(), WeaponManager::CanAttachMagazine(), WeaponManager::CanSwapMagazine(), Class::CastTo(), GetGame(), GetPlayer(), DayZPlayer::GetWeaponManager(), InventoryCombinationFlags::LOAD_CHAMBER, WeaponManager::LoadBullet(), m_Atts, m_Parent, m_player, InventoryCombinationFlags::NONE, Refresh(), InventoryCombinationFlags::SWAP, WeaponManager::SwapMagazine(), InventoryCombinationFlags::TAKE_TO_HANDS, and SplitItemUtils::TakeOrSplitToInventory().

OnSelectButton()

override bool HandsContainer::OnSelectButton ( )

inlineprotected

Definition at line 374 of file HandsContainer.c.

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

References Container::GetFocusedItem(), ItemManager::GetInstance(), Inventory(), and Container::Select().

OnShow()

override void HandsContainer::OnShow ( )

inlineprotected

Definition at line 1261 of file HandsContainer.c.

  {
    super.OnShow();
 
    for (int i = 0; i < m_Body.Count(); i++)
      m_Body.Get(i).OnShow();
  }

Refresh()

override void HandsContainer::Refresh ( )

inlineprotected

Definition at line 302 of file HandsContainer.c.

  {
    super.Refresh();
    SetActive(m_IsActive);
  }

References m_IsActive, and SetActive().

Referenced by DestroyAtt(), DestroyCargo(), DropReceived(), OnPerformCombination(), RefreshHands(), and ShowAtt().

RefreshHands()

void HandsContainer::RefreshHands ( )

inlineprotected

Definition at line 1136 of file HandsContainer.c.

  {
    for (int i = 0; i < m_Body.Count(); i++)
      m_Body.Get(i).OnShow();
    Refresh();
    m_Parent.Refresh();
  }

References m_Parent, and Refresh().

RemoveItem()

void HandsContainer::RemoveItem ( )

inlineprotected

Definition at line 789 of file HandsContainer.c.

  {
    m_Entity = null;
    m_CollapsibleHeader.ShowCollapseButtons(false, true);
  }

References m_CollapsibleHeader, and m_Entity.

ResetContainer()

void HandsContainer::ResetContainer ( )

inlineprotected

Definition at line 56 of file HandsContainer.c.

  {
    m_Body.Clear();
    m_Body.Insert(m_HandsPreview);
  }

References m_HandsPreview.

Referenced by ShowAtt().

ScrollToActiveContainer()

void HandsContainer::ScrollToActiveContainer ( Container active_container )

inlineprotected

Definition at line 158 of file HandsContainer.c.

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

References m_ScrollWidget, x, and y.

Referenced by SetFocusToIndex().

SetActive()

override void HandsContainer::SetActive ( bool active )

inlineprotected

Definition at line 253 of file HandsContainer.c.

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

References GetGame(), GetPlayer(), x, and y.

SetFocusToIndex()

void HandsContainer::SetFocusToIndex ( )

inlineprotected

Definition at line 72 of file HandsContainer.c.

  {
    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());
    }
  }

References m_AttachmentAttachments, m_AttachmentCargos, m_Atts, m_CargoGrid, m_ScrollWidget, and ScrollToActiveContainer().

SetLastActive()

override void HandsContainer::SetLastActive ( )

inlineprotected

Definition at line 280 of file HandsContainer.c.

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

References GetGame(), GetPlayer(), x, and y.

SetLayoutName()

override void HandsContainer::SetLayoutName ( )

inlineprotected

Definition at line 1256 of file HandsContainer.c.

  {
    m_LayoutName = WidgetLayoutName.ClosableContainer;
  }

References WidgetLayoutName::ClosableContainer.

ShowActionMenuCombine()

void HandsContainer::ShowActionMenuCombine ( EntityAI entity1, EntityAI entity2, int combinationFlags )

inlineprotected

Definition at line 655 of file HandsContainer.c.

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

References InventoryCombinationFlags::ADD_AS_ATTACHMENT, InventoryCombinationFlags::ADD_AS_CARGO, InventoryCombinationFlags::COMBINE_QUANTITY2, GetContextMenu(), GetGame(), GetMousePos(), InventoryCombinationFlags::LOAD_CHAMBER, InventoryCombinationFlags::NONE, PrintString(), InventoryCombinationFlags::SWAP, and InventoryCombinationFlags::TAKE_TO_HANDS.

ShowAtt()

void HandsContainer::ShowAtt ( EntityAI entity )

inlineprotected

Definition at line 1083 of file HandsContainer.c.

  {
    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();
  }

References AttachmentAdded(), AttachmentRemoved(), Container::CargoContainer(), InventorySlots::GetSlotName(), HideCargo(), Insert(), m_AttachmentSlotsSorted, m_Atts, m_CargoGrid, m_CollapsibleHeader, m_Entity, m_Parent, m_StaticAttCount, m_StaticCargoCount, Refresh(), ResetContainer(), and ShowCargo().

ShowCargo()

void HandsContainer::ShowCargo ( )

inlineprotected

Definition at line 1422 of file HandsContainer.c.

  {
    if (m_CargoGrid)
    {
      m_CargoGrid.OnShow();
      RecomputeOpenedContainers();
    }
  }

References m_CargoGrid.

Referenced by ShowAtt(), and UpdateInterval().

SplitItem()

override bool HandsContainer::SplitItem ( )

inlineprotected

Definition at line 208 of file HandsContainer.c.

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

References GetGame(), and GetPlayer().

TakeAsAttachment()

void HandsContainer::TakeAsAttachment ( Widget w, Widget receiver )

inlineprotected

Definition at line 1001 of file HandsContainer.c.

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

References GameInventory::CanSwapEntitiesEx(), Class::CastTo(), CombineItemsClient(), GetGame(), ItemManager::GetInstance(), GetItemPreviewItem(), GetPlayer(), m_Entity, and SplitItemUtils::TakeOrSplitToInventory().

Referenced by OnDropReceivedFromHeader(), and OnDropReceivedFromHeader2().

TransferItem()

override bool HandsContainer::TransferItem ( )

inlineprotected

Definition at line 185 of file HandsContainer.c.

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

References GetGame(), and GetPlayer().

TransferItemToVicinity()

override bool HandsContainer::TransferItemToVicinity ( )

inlineprotected

Definition at line 332 of file HandsContainer.c.

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

References GetGame(), and GetPlayer().

UnfocusAll()

override void HandsContainer::UnfocusAll ( )

inlineprotected

Definition at line 847 of file HandsContainer.c.

  {
    UnfocusGrid();
  }

References UnfocusGrid().

UnfocusGrid()

override void HandsContainer::UnfocusGrid ( )

inlineprotected

Definition at line 825 of file HandsContainer.c.

  {
    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();
    }
  }

References Container::CargoContainer(), m_AttachmentAttachments, m_AttachmentCargos, m_Atts, and m_CargoGrid.

Referenced by UnfocusAll().

UpdateInterval()

override void HandsContainer::UpdateInterval ( )

inlineprotected

Definition at line 1228 of file HandsContainer.c.

  {
    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();
  }

References ElectricityIcon(), HideCargo(), m_AttachmentCargos, m_Atts, m_CargoGrid, m_CollapsibleHeader, m_Entity, and ShowCargo().

Member Data Documentation

m_AttachmentAttachments

ref map<EntityAI, ref Attachments> HandsContainer::m_AttachmentAttachments

protected

Definition at line 12 of file HandsContainer.c.

Referenced by AttachmentAdded(), AttachmentRemoved(), DestroyAtt(), HandsContainer(), SetFocusToIndex(), UnfocusGrid(), and ~HandsContainer().

m_AttachmentAttachmentsContainers

ref map<EntityAI, AttachmentsWrapper> HandsContainer::m_AttachmentAttachmentsContainers

protected

Definition at line 11 of file HandsContainer.c.

Referenced by AttachmentAdded(), AttachmentRemoved(), DestroyAtt(), HandsContainer(), and ~HandsContainer().

m_AttachmentCargos

ref map<EntityAI, ref CargoContainer> HandsContainer::m_AttachmentCargos

protected

Definition at line 10 of file HandsContainer.c.

Referenced by AttachmentAdded(), AttachmentRemoved(), DestroyCargo(), DropReceived(), HandsContainer(), SetFocusToIndex(), UnfocusGrid(), UpdateInterval(), and ~HandsContainer().

m_AttachmentSlotsSorted

ref array<int> HandsContainer::m_AttachmentSlotsSorted

protected

Definition at line 13 of file HandsContainer.c.

Referenced by AttachmentAdded(), and ShowAtt().

m_Atts

ref Attachments HandsContainer::m_Atts

protected

Definition at line 7 of file HandsContainer.c.

Referenced by DestroyAtt(), OnPerformCombination(), SetFocusToIndex(), ShowAtt(), UnfocusGrid(), and UpdateInterval().

m_CargoGrid

ref CargoContainer HandsContainer::m_CargoGrid

protected

Definition at line 8 of file HandsContainer.c.

Referenced by DestroyCargo(), DropReceived(), HideCargo(), SetFocusToIndex(), ShowAtt(), ShowCargo(), UnfocusGrid(), and UpdateInterval().

m_CollapsibleHeader

ref HandsHeader HandsContainer::m_CollapsibleHeader

protected

Definition at line 4 of file HandsContainer.c.

Referenced by GetHeader(), HandsContainer(), RemoveItem(), ShowAtt(), and UpdateInterval().

m_HandsPreview

ref HandsPreview HandsContainer::m_HandsPreview

protected

Definition at line 5 of file HandsContainer.c.

Referenced by HandsContainer(), and ResetContainer().

m_Hidden

bool HandsContainer::m_Hidden

protected

Definition at line 3 of file HandsContainer.c.

Referenced by CollapseButtonOnMouseButtonDown().

m_ScrollWidget

ScrollWidget HandsContainer::m_ScrollWidget

protected

Definition at line 18 of file HandsContainer.c.

Referenced by HandsContainer(), ScrollToActiveContainer(), and SetFocusToIndex().

m_StaticAttCount

int HandsContainer::m_StaticAttCount = 0

protected

Definition at line 15 of file HandsContainer.c.

Referenced by ShowAtt().

m_StaticCargoCount

int HandsContainer::m_StaticCargoCount = 0

protected

Definition at line 16 of file HandsContainer.c.

Referenced by ShowAtt().

---

The documentation for this class was generated from the following file:

• scripts/5_Mission/GUI/InventoryNew/Containers/HandsContainer.c