VicinitySlotsContainer Class Reference

Inheritance diagram for VicinitySlotsContainer:

Collaboration diagram for VicinitySlotsContainer:

Protected Member Functions
void	VicinitySlotsContainer (LayoutHolder parent)
bool	IsItemWithContainerActive ()
override bool	IsItemWithQuantityActive ()
override bool	IsItemActive ()
bool	IsEmptyItemActive ()
override bool	IsDisplayable ()
bool	IsTakeable ()
override bool	CanCombineAmmo ()
override bool	EquipItem ()
override bool	InspectItem ()
override bool	TransferItem ()
override bool	Combine ()
override bool	Select ()
void	~VicinitySlotsContainer ()
override void	SetLayoutName ()
override void	OnShow ()
int	GetRowSlotCount ()
bool	ExcludeFromContainer (EntityAI item)
	Decides on the icon visibility.
void	ShowItemsInContainers (array< EntityAI > items)
void	DoubleClick (Widget w, int x, int y, int button)
string	GetItemQuantityText (EntityAI item)
int	HasItemQuantity (EntityAI item)
float	GetItemQuantity (InventoryItem item)
void	MouseButtonDown (Widget w, int x, int y, int button)
void	MouseClick (Widget w, int x, int y, int button)
override void	OnDropReceivedFromHeader (Widget w, int x, int y, Widget receiver)
void	RecomputeNumberOfContainers (array< EntityAI > items)

Protected Attributes
ref AttachmentsGroupContainer	m_Container
int	m_ItemsCount
int	m_SlotsCount
ref array< EntityAI >	m_ShowedItems

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 VicinitySlotsContainer.c.

Constructor & Destructor Documentation

VicinitySlotsContainer()

void VicinitySlotsContainer::VicinitySlotsContainer ( LayoutHolder parent )

inlineprotected

Definition at line 8 of file VicinitySlotsContainer.c.

  {
    m_Container = new AttachmentsGroupContainer(this);
    ref SlotsContainer con = new SlotsContainer(m_Container, null);
    m_Container.Insert(con);
    m_Body.Insert(m_Container);
    for (int j = 0; j < ITEMS_IN_ROW; j++)
    {
      SlotsIcon icon = con.GetSlotIcon(j);
      WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetPanelWidget(), m_Parent, "OnDropReceivedFromIcon");
      WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetGhostSlot(), m_Parent, "OnDropReceivedFromHeader");
      WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetMainWidget(), m_Parent, "OnDropReceivedFromHeader");
 
      WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetPanelWidget(), m_Parent, "DraggingOverIcon");
      WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetGhostSlot(), m_Parent, "DraggingOverHeader");
      WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetMainWidget(), m_Parent, "DraggingOverHeader");
 
      WidgetEventHandler.GetInstance().RegisterOnDoubleClick(icon.GetPanelWidget(), this, "DoubleClick");
      WidgetEventHandler.GetInstance().RegisterOnMouseButtonUp(icon.GetPanelWidget(), this, "MouseClick");
      WidgetEventHandler.GetInstance().RegisterOnMouseButtonDown(icon.GetPanelWidget(), this, "MouseButtonDown");
    }
 
    con.SetColumnCount(0);
    con.SetForceShow(true);
 
    WidgetEventHandler.GetInstance().RegisterOnDropReceived(m_Container.GetMainWidget(), m_Parent, "OnDropReceivedFromHeader");
    WidgetEventHandler.GetInstance().RegisterOnDraggingOver(m_Container.GetMainWidget(), m_Parent, "DraggingOverHeader");
 
    m_ShowedItems = new array<EntityAI>;
  }

References WidgetEventHandler::GetInstance(), ITEMS_IN_ROW, m_Container, m_Parent, and m_ShowedItems.

~VicinitySlotsContainer()

void VicinitySlotsContainer::~VicinitySlotsContainer ( )

inlineprotected

Definition at line 212 of file VicinitySlotsContainer.c.

  {
    for (int i = 0; i < m_Container.Count(); i++)
    {
      Container c = ClosableContainer.Cast(m_Container.Get(i / ITEMS_IN_ROW));
      if (c && c.GetMainWidget())
        delete m_Container.Get(i / ITEMS_IN_ROW).GetMainWidget();
    }
  }

References ITEMS_IN_ROW, and m_Container.

Member Function Documentation

CanCombineAmmo()

override bool VicinitySlotsContainer::CanCombineAmmo ( )

inlineprotected

Definition at line 76 of file VicinitySlotsContainer.c.

  {
    PlayerBase m_player = PlayerBase.Cast(GetGame().GetPlayer());
    ItemBase ent = ItemBase.Cast(GetFocusedItem());
    ItemBase item_in_hands = ItemBase.Cast(GetGame().GetPlayer().GetHumanInventory().GetEntityInHands());
    ActionManagerClient amc;
    Class.CastTo(amc, m_player.GetActionManager());
 
    return (amc.CanPerformActionFromInventory(item_in_hands, ent) || amc.CanSetActionFromInventory(item_in_hands, ent));
  }

References Class::CastTo(), Container::GetFocusedItem(), GetGame(), GetPlayer(), and m_player.

Combine()

override bool VicinitySlotsContainer::Combine ( )

inlineprotected

Definition at line 139 of file VicinitySlotsContainer.c.

  {
    ItemBase ent = ItemBase.Cast(GetFocusedItem());
 
    ItemBase item_in_hands = ItemBase.Cast(GetGame().GetPlayer().GetHumanInventory().GetEntityInHands());
 
    Icon hands_icon = ItemManager.GetInstance().GetHandsPreview().GetIcon();
 
    if (item_in_hands && ent && hands_icon)
      return hands_icon.CombineItems(item_in_hands, ent);
    return false;
  }

References Container::GetFocusedItem(), GetGame(), ItemManager::GetInstance(), and GetPlayer().

DoubleClick()

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

inlineprotected

Definition at line 326 of file VicinitySlotsContainer.c.

  {
    if (button == MouseState.LEFT && !g_Game.IsLeftCtrlDown())
    {
      if (w == null)
        return;
      ItemPreviewWidget iw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
      if (!iw)
      {
        string name = w.GetName();
        name.Replace("PanelWidget", "Render");
        iw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
      }
 
      if (!iw)
        iw = ItemPreviewWidget.Cast(w);
 
      ItemBase item = ItemBase.Cast(iw.GetItem());
      if (!item)
        return;
 
      if (!item.IsTakeable())
        return;
 
      if (GetGame().GetPlayer().GetInventory().HasInventoryReservation(item, null))
        return;
 
      if (!item.GetInventory().CanRemoveEntity())
        return;
 
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
      if (player.GetInventory().HasEntityInInventory(item) && GetGame().GetPlayer().GetHumanInventory().CanAddEntityInHands(item))
        player.PredictiveTakeEntityToHands(item);
      else
      {
        InventoryLocation dst = new InventoryLocation;
        player.GetInventory().FindFreeLocationFor(item, FindInventoryLocationType.ANY, dst);
        if (dst.IsValid() && player.GetInventory().LocationCanAddEntity(dst))
          SplitItemUtils.TakeOrSplitToInventoryLocation(player, dst);
      }
 
      HideOwnedTooltip();
      InventoryMenu menu = InventoryMenu.Cast(GetGame().GetUIManager().FindMenu(MENU_INVENTORY));
      if (menu)
        menu.RefreshQuickbar();
    }
  }

References g_Game, GetGame(), GetPlayer(), InventoryMenu(), MENU_INVENTORY, name, and SplitItemUtils::TakeOrSplitToInventoryLocation().

EquipItem()

override bool VicinitySlotsContainer::EquipItem ( )

inlineprotected

Definition at line 87 of file VicinitySlotsContainer.c.

  {
    if (CanEquip())
    {
      EntityAI ent = GetFocusedItem();
      bool res = false;
 
      if (ent && !ent.IsInherited(Magazine))
      {
        res = GetGame().GetPlayer().PredictiveTakeOrSwapAttachment(ent);
        if (!res)
          res = GetGame().GetPlayer().GetInventory().TakeEntityToInventory(InventoryMode.JUNCTURE, FindInventoryLocationType.ATTACHMENT, ent);
      }
      return res;
    }
    return false;
  }

References Container::GetFocusedItem(), and GetGame().

ExcludeFromContainer()

bool VicinitySlotsContainer::ExcludeFromContainer ( EntityAI item )

inlineprotected

Decides on the icon visibility.

Definition at line 238 of file VicinitySlotsContainer.c.

  {
    int mask = item.GetHideIconMask();
    return mask & EInventoryIconVisibility.HIDE_VICINITY;
  }

Referenced by ShowItemsInContainers().

GetItemQuantity()

float VicinitySlotsContainer::GetItemQuantity ( InventoryItem item )

inlineprotected

Definition at line 431 of file VicinitySlotsContainer.c.

  {
    float quantity = 0;
    if (item.IsInherited(InventoryItem))
    {
      ItemBase item_base = ItemBase.Cast(item);
      if (item.IsInherited(Magazine))
      {
        Magazine magazine_item = Magazine.Cast(item);
        quantity = magazine_item.GetAmmoCount();
      }
      else
        quantity = item_base.GetQuantity();
    }
    return quantity;
  }

GetItemQuantityText()

string VicinitySlotsContainer::GetItemQuantityText ( EntityAI item )

inlineprotected

Definition at line 375 of file VicinitySlotsContainer.c.

  {
    string quantity_text = "";
    if (item.IsInherited(InventoryItem))
    {
      ItemBase item_base = ItemBase.Cast(item);
      float quantity = item_base.GetQuantity();
      int ammo;
      if (item.IsInherited(Magazine))
      {
        Magazine magazine_item = Magazine.Cast(item);
        ammo = magazine_item.GetAmmoCount();
        quantity_text = ammo.ToString();
        return quantity_text;
      }
      else if (item.IsInherited(ItemBook))
        return "";
      int max = item.GetQuantityMax();
      //string unit = item.ConfigGetString( "stackedUnit" );
 
      if (max > 0)
      {
        if (max == 1)
        {
          float tmp = Math.Round((quantity / max) * 100);
          quantity_text = tmp.ToString() + "%";
        }
        else
          quantity_text = quantity.ToString();
      }
    }
    return quantity_text;
  }

References Math::Round().

GetRowSlotCount()

int VicinitySlotsContainer::GetRowSlotCount ( )

inlineprotected

Definition at line 232 of file VicinitySlotsContainer.c.

  {
    return GetFocusedContainer().GetColumnCount();
  }

HasItemQuantity()

int VicinitySlotsContainer::HasItemQuantity ( EntityAI item )

inlineprotected

Definition at line 409 of file VicinitySlotsContainer.c.

  {
    if (item.IsInherited(InventoryItem))
    {
      ItemBase item_base = ItemBase.Cast(item);
      if (item.IsInherited(Magazine))
        return QUANTITY_COUNT;
      else if (item.IsInherited(ItemBook))
        return QUANTITY_HIDDEN;
      int max = item.GetQuantityMax();
      bool bar = item.ConfigGetBool("quantityBar");
      if (max > 0)
      {
        if (max == 1 || bar)
          return QUANTITY_PROGRESS;
        else
          return QUANTITY_COUNT;
      }
    }
    return QUANTITY_HIDDEN;
  }

References QUANTITY_COUNT, QUANTITY_HIDDEN, and QUANTITY_PROGRESS.

InspectItem()

override bool VicinitySlotsContainer::InspectItem ( )

inlineprotected

Definition at line 105 of file VicinitySlotsContainer.c.

  {
    EntityAI ent = GetFocusedItem();
 
    if (ent)
    {
      InspectItem(ent);
      return true;
    }
    return false;
  }

References Container::GetFocusedItem(), and InspectItem().

Referenced by InspectItem(), and MouseClick().

IsDisplayable()

override bool VicinitySlotsContainer::IsDisplayable ( )

inlineprotected

Definition at line 65 of file VicinitySlotsContainer.c.

  {
    return true;
  }

IsEmptyItemActive()

bool VicinitySlotsContainer::IsEmptyItemActive ( )

inlineprotected

Definition at line 58 of file VicinitySlotsContainer.c.

  {
    EntityAI ent = GetFocusedItem();
    return ent == null;
  }

References Container::GetFocusedItem().

IsItemActive()

override bool VicinitySlotsContainer::IsItemActive ( )

inlineprotected

Definition at line 52 of file VicinitySlotsContainer.c.

  {
    EntityAI ent = GetFocusedItem();
    return ent && !IsItemWithQuantityActive() && !IsItemWithContainerActive();
  }

References Container::GetFocusedItem(), IsItemWithContainerActive(), and IsItemWithQuantityActive().

IsItemWithContainerActive()

bool VicinitySlotsContainer::IsItemWithContainerActive ( )

inlineprotected

Definition at line 39 of file VicinitySlotsContainer.c.

  {
    EntityAI ent = GetFocusedItem();
    return ent && (ent.GetInventory().GetCargo() || (ent.GetSlotsCountCorrect() > 0 && ent.CanDisplayAnyAttachmentSlot()));
    //TODO: also check for cargo visibility maybe?
  }

References Container::GetFocusedItem().

Referenced by IsItemActive().

IsItemWithQuantityActive()

override bool VicinitySlotsContainer::IsItemWithQuantityActive ( )

inlineprotected

Definition at line 46 of file VicinitySlotsContainer.c.

  {
    EntityAI ent = GetFocusedItem();
    return ent && QuantityConversions.HasItemQuantity(ent) && ent.CanBeSplit();
  }

References Container::GetFocusedItem(), and QuantityConversions::HasItemQuantity().

Referenced by IsItemActive().

IsTakeable()

bool VicinitySlotsContainer::IsTakeable ( )

inlineprotected

Definition at line 70 of file VicinitySlotsContainer.c.

  {
    EntityAI ent = GetFocusedItem();
    return ent.IsTakeable();
  }

References Container::GetFocusedItem().

MouseButtonDown()

void VicinitySlotsContainer::MouseButtonDown ( Widget w, int x, int y, int button )

inlineprotected

Definition at line 449 of file VicinitySlotsContainer.c.

  {
    string name = w.GetName();
    name.Replace("PanelWidget", "Render");
    ItemPreviewWidget item_preview = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
    ItemBase item = ItemBase.Cast(item_preview.GetItem());
    bool draggable = ItemManager.GetInstance().EvaluateContainerDragabilityDefault(item);
    ItemManager.GetInstance().SetWidgetDraggable(w, draggable);
  }

References ItemManager::GetInstance(), and name.

MouseClick()

void VicinitySlotsContainer::MouseClick ( Widget w, int x, int y, int button )

inlineprotected

Definition at line 460 of file VicinitySlotsContainer.c.

  {
    string name = w.GetName();
    name.Replace("PanelWidget", "Render");
    ItemPreviewWidget item_preview = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
    EntityAI item = item_preview.GetItem();
    InventoryItem itemAtPos = InventoryItem.Cast(item);
    Container conta;
 
#ifdef DIAG_DEVELOPER
    if (ItemBase.Cast(item))
    {
      if (GetDayZGame().IsLeftCtrlDown() && button == MouseState.RIGHT)
        ShowActionMenu(ItemBase.Cast(item));
    }
#endif
 
    if (m_Parent)
    {
      ref map<int, ref Container> showed_items = (VicinityContainer.Cast(m_Parent)).m_ShowedItemsIDs;
 
      if (item && showed_items)
      {
        conta = showed_items.Get(item.GetID());
 
        (VicinityContainer.Cast(m_Parent)).ToggleContainer(w, item);
        if (button == MouseState.RIGHT)
        {
          if (itemAtPos)
            itemAtPos.OnRightClick();
        }
        else if (button == MouseState.MIDDLE)
        {
          InspectItem(itemAtPos);
          return;
        }
      }
    }
  }

References GetDayZGame(), InspectItem(), m_Parent, and name.

OnDropReceivedFromHeader()

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

inlineprotected

Definition at line 500 of file VicinitySlotsContainer.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.IsInherited(ItemPreviewWidget))
      return;
 
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    ItemBase item = ItemBase.Cast(ipw.GetItem());
 
    if (item)
    {
      if (!item.GetInventory().CanRemoveEntity())
        return;
 
      if (player.CanDropEntity(item))
      {
        if (item.GetTargetQuantityMax() < item.GetQuantity())
          item.SplitIntoStackMaxClient(null, -1);
        else
          player.PhysicalPredictiveDropItem(item);
      }
    }
  }

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

OnShow()

override void VicinitySlotsContainer::OnShow ( )

inlineprotected

Definition at line 227 of file VicinitySlotsContainer.c.

  {
    super.OnShow();
  }

RecomputeNumberOfContainers()

void VicinitySlotsContainer::RecomputeNumberOfContainers ( array< EntityAI > items )

inlineprotected

Definition at line 533 of file VicinitySlotsContainer.c.

  {
    int number_of_containers = m_Container.m_Body.Count();
    int number_of_containers_needed = (items.Count() / ITEMS_IN_ROW) + 1;
    int difference = number_of_containers_needed - number_of_containers;
    int g;
 
    for (g = number_of_containers; g < number_of_containers_needed; g++)
    {
      SlotsContainer con = new SlotsContainer(m_Container, null);
      m_Container.Insert(con, -1, false);
      for (int j = 0; j < ITEMS_IN_ROW; j++)
      {
        SlotsIcon icon = con.GetSlotIcon(j);
        WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetPanelWidget(), m_Parent, "OnDropReceivedFromIcon");
        WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetGhostSlot(), m_Parent, "OnDropReceivedFromHeader");
        WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetMainWidget(), m_Parent, "OnDropReceivedFromHeader");
 
        WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetPanelWidget(), m_Parent, "DraggingOverIcon");
        WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetGhostSlot(), m_Parent, "DraggingOverHeader");
        WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetMainWidget(), m_Parent, "DraggingOverHeader");
 
        WidgetEventHandler.GetInstance().RegisterOnDoubleClick(icon.GetPanelWidget(), this, "DoubleClick");
        WidgetEventHandler.GetInstance().RegisterOnMouseButtonUp(icon.GetPanelWidget(), this, "MouseClick");
        WidgetEventHandler.GetInstance().RegisterOnMouseButtonDown(icon.GetPanelWidget(), this, "MouseButtonDown");
      }
 
      con.SetColumnCount(items.Count() % ITEMS_IN_ROW);
    }
 
    for (g = number_of_containers - 1 ; g >= number_of_containers_needed ; g--)
    {
      Widget w = m_Container.m_Body.Get(g).GetMainWidget();
      delete w;
      m_Container.m_Body.Remove(g);
    }
 
    if ((items.Count() % ITEMS_IN_ROW) == 0)
      SlotsContainer.Cast(m_Container.Get(number_of_containers_needed - 1)).SetColumnCount(ITEMS_IN_ROW);
    else
      SlotsContainer.Cast(m_Container.Get(number_of_containers_needed - 1)).SetColumnCount(items.Count() % ITEMS_IN_ROW);
 
    for (int i = 0; i < number_of_containers_needed - 1; i++)
      SlotsContainer.Cast(m_Container.Get(i)).SetColumnCount(ITEMS_IN_ROW);
 
    RecomputeOpenedContainers();
    m_Container.RecomputeOpenedContainers();
  }

References WidgetEventHandler::GetInstance(), ITEMS_IN_ROW, m_Container, and m_Parent.

Referenced by ShowItemsInContainers().

Select()

override bool VicinitySlotsContainer::Select ( )

inlineprotected

Definition at line 152 of file VicinitySlotsContainer.c.

  {
    SlotsIcon selected_slot = ItemManager.GetInstance().GetSelectedIcon();
    EntityAI ent = GetFocusedItem();
    ItemBase selected_item = ItemBase.Cast(ItemManager.GetInstance().GetSelectedItem());
 
    if (!(selected_slot && selected_slot.IsOutOfReach()))
    {
      if (selected_item)
      {
        if (ent != selected_item)
        {
          if (selected_item && GetGame().GetPlayer().CanDropEntity(selected_item))
          {
            bool draggable = false;
 
            PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
            draggable = !player.GetInventory().HasInventoryReservation(selected_item, null) && !player.IsItemsToDelete();
            draggable = draggable && selected_item.GetInventory().CanRemoveEntity();
 
            if (draggable && m_ShowedItems.Find(selected_item) == -1)
            {
              if (selected_item.GetTargetQuantityMax() < selected_item.GetQuantity())
                selected_item.SplitIntoStackMaxClient(null, -1);
              else
                player.PhysicalPredictiveDropItem(selected_item);
              ItemManager.GetInstance().SetSelectedItemEx(null, null, null);
              return true;
            }
          }
        }
      }
      else
      {
        if (ent && ent.GetInventory().CanRemoveEntity())
        {
          EntityAI item_in_hands = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
          if (item_in_hands)
          {
            if (GameInventory.CanSwapEntitiesEx(item_in_hands, ent))
            {
              GetGame().GetPlayer().PredictiveSwapEntities(item_in_hands, ent);
              return true;
            }
          }
          else
          {
            if (GetGame().GetPlayer().GetHumanInventory().CanAddEntityInHands(ent))
            {
              GetGame().GetPlayer().PredictiveTakeEntityToHands(ent);
              return true;
            }
          }
        }
      }
    }
 
    return false;
  }

References GameInventory::CanSwapEntitiesEx(), Container::GetFocusedItem(), GetGame(), ItemManager::GetInstance(), GetPlayer(), and m_ShowedItems.

SetLayoutName()

override void VicinitySlotsContainer::SetLayoutName ( )

inlineprotected

Definition at line 222 of file VicinitySlotsContainer.c.

  {
    m_LayoutName = WidgetLayoutName.Container;
  }

References WidgetLayoutName::Container.

ShowItemsInContainers()

void VicinitySlotsContainer::ShowItemsInContainers ( array< EntityAI > items )

inlineprotected

Definition at line 244 of file VicinitySlotsContainer.c.

  {
    EntityAI item;
    SlotsIcon icon;
    int x;
    int visible_items_count = 0;
    int visible_rows = 0;
    ref array<EntityAI> visible_items = new array<EntityAI>;
 
    for (x = 0; x < items.Count(); ++x)
    {
      item = items.Get(x);
 
      if (item == null || ExcludeFromContainer(item))
        continue;
 
      visible_items.Insert(item);
      visible_items_count++;
    }
 
    RecomputeNumberOfContainers(visible_items);
 
    for (x = 0; x < visible_items_count; ++x)
    {
      item = visible_items.Get(x);
      int row = (int)Math.Floor(x / ITEMS_IN_ROW);
      int column = x % ITEMS_IN_ROW;
      icon = SlotsContainer.Cast(m_Container.Get(row)).GetSlotIcon(column);
 
      icon.GetMainWidget().Show(true);
      icon.GetPanelWidget().SetUserID(item.GetID());
 
      if (m_ShowedItems.Find(item) != x)
        icon.Init(item);
      icon.UpdateInterval();
 
      if (!ItemManager.GetInstance().IsDragging())
        ItemManager.GetInstance().SetTemperature(item, icon.GetRender());
 
      bool draggable = ItemManager.GetInstance().EvaluateContainerDragabilityDefault(item);
      if (!draggable && GetDragWidget() == icon.GetPanelWidget())
        CancelWidgetDragging();
      ItemManager.GetInstance().SetWidgetDraggable(icon.GetPanelWidget(), draggable);
 
      ref map<int, ref Container> showed_items = (VicinityContainer.Cast(m_Parent)).m_ShowedItemsIDs;
 
      Container conta = Container.Cast(showed_items.Get(item.GetID()));
      if (conta)
        conta.SetSlotIcon(icon);
 
      if (conta && conta.IsDisplayable())
        conta.UpdateRadialIcon();
      else
      {
        icon.GetRadialIconPanel().Show(false);
        if (conta)
          conta.OnHide();
      }
    }
 
    SlotsContainer slots_last = SlotsContainer.Cast(m_Container.Get(visible_items.Count() / ITEMS_IN_ROW));
 
    for (int c = visible_items_count % ITEMS_IN_ROW; c < ITEMS_IN_ROW; ++c)
    {
      icon = slots_last.GetSlotIcon(c);
      icon.GetMainWidget().Show(false);
      icon.Clear();
    }
 
    //#ifndef PLATFORM_CONSOLE
    if (visible_items_count % ITEMS_IN_ROW == 0)
    {
      slots_last = SlotsContainer.Cast(m_Container.Get(m_Container.Count() - 1));
      slots_last.GetSlotIcon(0).GetMainWidget().Show(true);
      slots_last.GetSlotIcon(0).GetGhostSlot().Show(false);
      slots_last.GetMainWidget().Update();
    }
    //#endif
 
    m_ShowedItems = visible_items;
  }

References CancelWidgetDragging(), ExcludeFromContainer(), Math::Floor(), GetDragWidget(), ItemManager::GetInstance(), ITEMS_IN_ROW, m_Container, m_Parent, m_ShowedItems, RecomputeNumberOfContainers(), and x.

TransferItem()

override bool VicinitySlotsContainer::TransferItem ( )

inlineprotected

Definition at line 117 of file VicinitySlotsContainer.c.

  {
    if (CanTakeToInventory())
    {
      ItemBase ent = ItemBase.Cast(GetFocusedItem());
      if (ent)
      {
        if (ent.IsTakeable())
        {
          InventoryLocation il = new InventoryLocation;
          GetGame().GetPlayer().GetInventory().FindFreeLocationFor(ent, FindInventoryLocationType.CARGO, il);
          if (il.IsValid() && GetGame().GetPlayer().GetInventory().LocationCanAddEntity(il))
          {
            SplitItemUtils.TakeOrSplitToInventoryLocation(PlayerBase.Cast(GetGame().GetPlayer()), il);
            return true;
          }
        }
      }
    }
    return false;
  }

References Container::GetFocusedItem(), GetGame(), GetPlayer(), and SplitItemUtils::TakeOrSplitToInventoryLocation().

Member Data Documentation

m_Container

ref AttachmentsGroupContainer VicinitySlotsContainer::m_Container

protected

Definition at line 3 of file VicinitySlotsContainer.c.

Referenced by RecomputeNumberOfContainers(), ShowItemsInContainers(), VicinitySlotsContainer(), and ~VicinitySlotsContainer().

m_ItemsCount

int VicinitySlotsContainer::m_ItemsCount

protected

Definition at line 4 of file VicinitySlotsContainer.c.

m_ShowedItems

ref array<EntityAI> VicinitySlotsContainer::m_ShowedItems

protected

Definition at line 6 of file VicinitySlotsContainer.c.

Referenced by Select(), ShowItemsInContainers(), and VicinitySlotsContainer().

m_SlotsCount

int VicinitySlotsContainer::m_SlotsCount

protected

Definition at line 5 of file VicinitySlotsContainer.c.

---

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

• scripts/5_Mission/GUI/InventoryNew/Inherited/VicinitySlotsContainer.c