AttachmentCategoriesRow Class Reference

Inheritance diagram for AttachmentCategoriesRow:

Collaboration diagram for AttachmentCategoriesRow:

Protected Member Functions
void	AttachmentCategoriesRow (LayoutHolder parent, int sort=-1)
string	GetCategoryIdentifier ()
int	GetFocusedSlot ()
override bool	Select ()
override bool	TransferItem ()
override bool	TransferItemToVicinity ()
override bool	Combine ()
override bool	CanSplitEx (EntityAI focusedItem)
override bool	SplitItem ()
override bool	EquipItem ()
override bool	CanCombine ()
override bool	CanCombineAmmo ()
override bool	IsItemActive ()
override bool	IsItemWithQuantityActive ()
override void	OnDropReceivedFromHeader (Widget w, int x, int y, Widget receiver)
override void	UnfocusAll ()
override void	DraggingOverHeader (Widget w, int x, int y, Widget receiver)
bool	DraggingOverGrid (Widget w, int x, int y, Widget reciever, CargoContainer cargo)
void	DropReceived (Widget w, int x, int y, CargoContainer cargo)
EntityAI	GetItemPreviewItem (Widget w)
override void	Refresh ()
void	RefreshAllSlots ()
void	RefreshSlot (int row, int column, int slot_id, string slot_name)
void	DoubleClick (Widget w, int x, int y, int button)
void	MouseClick (Widget w, int x, int y, int button)
void	Init (int attachments_categories_count, int i, string attachment_category, string config_path_attachment_categories, EntityAI entity, int parent_m_Body_count)
override void	UpdateInterval ()

Protected Attributes
string	m_CategoryIdentifier
string	m_RowConfigPath
bool	m_Refreshing
ref AttachmentsGroupContainer	m_AttachmentsContainer
ref map< int, ref ContainerWithCargo >	m_AttachmentCargos

Additional Inherited Members
Private Member Functions inherited from ClosableContainer
void	ContainerWithCargo (Container parent, int sort=-1)
override bool	IsDisplayable ()
override bool	IsEmpty ()
override bool	IsItemActive ()
override bool	CanCombine ()
override bool	CanCombineAmmo ()
override bool	IsItemWithQuantityActive ()
void	LockCargo (bool value)
override void	Open ()
override void	Close ()
override bool	IsOpened ()
override void	UpdateInterval ()
override bool	IsFirstContainerFocused ()
override bool	IsLastContainerFocused ()
override void	SetDefaultFocus (bool while_micromanagment_mode=false)
override void	UnfocusAll ()
override bool	SplitItem ()
override bool	EquipItem ()
override bool	TransferItem ()
override bool	TransferItemToVicinity ()
override bool	InspectItem ()
void	SetEntity (EntityAI entity, int cargo_index=0, bool immedUpdate=true)
EntityAI	GetEntity ()
override EntityAI	GetFocusedContainerEntity ()
EntityAI	GetItemPreviewItem (Widget w)
bool	DraggingOverGrid (Widget w, int x, int y, Widget reciever)
void	DropReceived (Widget w, int x, int y)
void	TakeIntoHands (notnull PlayerBase player, notnull EntityAI item)
override void	DraggingOverHeader (Widget w, int x, int y, Widget receiver)
override void	DraggingOver (Widget w, int x, int y, Widget receiver)
override void	OnDropReceivedFromHeader (Widget w, int x, int y, Widget receiver)
void	ContainerWithCargoAndAttachments (LayoutHolder parent, int sort=-1)
void	~ContainerWithCargoAndAttachments ()
void	RecomputeContainers ()
void	AttachmentAddedEx (EntityAI item, string slot, EntityAI parent, bool immedUpdate=true)
void	AttachmentAdded (EntityAI item, string slot, EntityAI parent)
void	AttachmentRemoved (EntityAI item, string slot, EntityAI parent)
override void	UpdateInterval ()
override EntityAI	GetFocusedContainerEntity ()
override void	UnfocusAll ()
override bool	IsLastIndex ()
override bool	IsFirstContainerFocused ()
override bool	IsLastContainerFocused ()
override void	MoveGridCursor (int direction)
void	SetEntity (EntityAI entity, bool immedUpdate=true)
void	HideCargo ()
void	ShowCargo ()
EntityAI	GetEntity ()
ItemPreviewWidget	GetItemPreviewWidgetDragOrDrop (Widget w)
EntityAI	GetItemPreviewItem (Widget w)
Widget	GetItemPreviewWidget (Widget w)
void	MouseClick2 (Widget w, int x, int y, int button)
void	DropReceived (Widget w, int x, int y, CargoContainer cargo)
	NOTE Used for mouse only.
void	TakeAsAttachment (Widget w, Widget receiver)
override void	OnDropReceivedFromHeader (Widget w, int x, int y, Widget receiver)
void	OnDropReceivedFromHeader2 (Widget w, int x, int y, Widget receiver)
void	DoubleClick (Widget w, int x, int y, int button)
bool	DraggingOverGrid (Widget w, int x, int y, Widget reciever, CargoContainer cargo)
override void	DraggingOver (Widget w, int x, int y, Widget receiver)
override void	DraggingOverHeader (Widget w, int x, int y, Widget receiver)
Private Attributes inherited from ClosableContainer
ref CargoContainer	m_CargoGrid
int	m_CargoIndex = -1
ref Attachments	m_Atts
ref map< EntityAI, ref CargoContainer >	m_AttachmentCargos
ref map< EntityAI, ref AttachmentsWrapper >	m_AttachmentAttachmentsContainers
ref map< EntityAI, ref Attachments >	m_AttachmentAttachments
ref array< int >	m_AttachmentSlotsSorted

Detailed Description

Definition at line 1 of file AttachmentCategoriesRow.c.

Constructor & Destructor Documentation

AttachmentCategoriesRow()

void AttachmentCategoriesRow::AttachmentCategoriesRow ( LayoutHolder parent, int sort = -1 )

inlineprotected

Definition at line 10 of file AttachmentCategoriesRow.c.

  {
    m_Refreshing = false;
    m_AttachmentCargos = new map<int, ref ContainerWithCargo>;
    m_AttachmentsContainer = new AttachmentsGroupContainer(this);
 
    m_Body.Insert(m_AttachmentsContainer);
 
    m_ClosableHeader.GetMainWidget().ClearFlags(WidgetFlags.DRAGGABLE);
 
    RecomputeOpenedContainers();
  }

References m_AttachmentCargos, m_AttachmentsContainer, and m_Refreshing.

Member Function Documentation

CanCombine()

override bool AttachmentCategoriesRow::CanCombine ( )

inlineprotected

Definition at line 242 of file AttachmentCategoriesRow.c.

  {
    Man player = GetGame().GetPlayer();
    ItemBase prev_item = ItemBase.Cast(GetFocusedItem());
    ItemBase selected_item = ItemBase.Cast(player.GetHumanInventory().GetEntityInHands());
    SlotsIcon focused_icon = GetFocusedSlotsIcon();
 
    if (selected_item)
    {
      int selected_slot = GetFocusedSlot();
      int stack_max;
      if (selected_item && selected_item.GetInventory().CanRemoveEntity() && (focused_icon && !focused_icon.IsOutOfReach()))
      {
        if (m_Entity.GetInventory().CanAddAttachmentEx(selected_item, selected_slot))
        {
          stack_max = InventorySlots.GetStackMaxForSlotId(selected_slot);
          float quantity = selected_item.GetQuantity();
          if (stack_max == 0 || stack_max >= quantity || !selected_item.CanBeSplit())
            return true;
          else
            return true;
        }
        else if (selected_slot != -1)
        {
          if (prev_item)
          {
            InventoryLocation inv_loc = new InventoryLocation;
            prev_item.GetInventory().GetCurrentInventoryLocation(inv_loc);
            stack_max = InventorySlots.GetStackMaxForSlotId(inv_loc.GetSlot());
            quantity = prev_item.GetQuantity();
            if (prev_item.CanBeCombined(ItemBase.Cast(selected_item)))
              return true;
          }
        }
      }
    }
    return false;
  }

References GetFocusedSlot(), GetGame(), InventorySlots::GetStackMaxForSlotId(), and m_Entity.

Referenced by Combine().

CanCombineAmmo()

override bool AttachmentCategoriesRow::CanCombineAmmo ( )

inlineprotected

Definition at line 281 of file AttachmentCategoriesRow.c.

  {
    return false;
  }

CanSplitEx()

override bool AttachmentCategoriesRow::CanSplitEx ( EntityAI focusedItem )

inlineprotected

Definition at line 227 of file AttachmentCategoriesRow.c.

  {
    return false;
  }

Combine()

override bool AttachmentCategoriesRow::Combine ( )

inlineprotected

Definition at line 163 of file AttachmentCategoriesRow.c.

  {
    if (CanCombine())
    {
      Man player = GetGame().GetPlayer();
      ItemBase prev_item = ItemBase.Cast(GetFocusedItem());
      ItemBase selected_item = ItemBase.Cast(player.GetHumanInventory().GetEntityInHands());
      SlotsIcon focused_icon = GetFocusedSlotsIcon();
 
      if (selected_item)
      {
        int selected_slot = GetFocusedSlot();
        int stack_max;
        if (selected_item && selected_item.GetInventory().CanRemoveEntity() && (focused_icon && !focused_icon.IsOutOfReach()))
        {
          if (!prev_item && m_Entity.GetInventory().CanAddAttachmentEx(selected_item, selected_slot))
          {
            stack_max = InventorySlots.GetStackMaxForSlotId(selected_slot);
            float quantity = selected_item.GetQuantity();
            if (stack_max == 0 || stack_max >= quantity || !selected_item.CanBeSplit())
            {
              player.PredictiveTakeEntityToTargetAttachmentEx(m_Entity, selected_item, selected_slot);
              return true;
            }
            else
            {
              selected_item.SplitIntoStackMaxClient(m_Entity, selected_slot);
              return true;
            }
          }
          else if (selected_slot != -1)
          {
            if (prev_item)
            {
              InventoryLocation inv_loc = new InventoryLocation;
              prev_item.GetInventory().GetCurrentInventoryLocation(inv_loc);
              stack_max = InventorySlots.GetStackMaxForSlotId(inv_loc.GetSlot());
              quantity = prev_item.GetQuantity();
              if (prev_item.CanBeCombined(ItemBase.Cast(selected_item)))
              {
                prev_item.CombineItemsClient(selected_item, true);
                return true;
              }
              else if (stack_max == 0 && GameInventory.CanSwapEntitiesEx(prev_item, selected_item))
              {
                player.PredictiveSwapEntities(selected_item, prev_item);
                return true;
              }
              else if (m_AttachmentCargos.Contains(inv_loc.GetSlot()))
              {
                if (prev_item.GetInventory().CanAddEntityInCargo(selected_item, selected_item.GetInventory().GetFlipCargo()))
                {
                  SplitItemUtils.TakeOrSplitToInventory(PlayerBase.Cast(player), prev_item, selected_item);
                  return true;
                }
              }
            }
          }
        }
      }
    }
    return false;
  }

References CanCombine(), GameInventory::CanSwapEntitiesEx(), GetFocusedSlot(), GetGame(), InventorySlots::GetStackMaxForSlotId(), m_AttachmentCargos, m_Entity, and SplitItemUtils::TakeOrSplitToInventory().

DoubleClick()

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

inlineprotected

Definition at line 704 of file AttachmentCategoriesRow.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);
 
      SlotsIcon icon;
      w.GetUserData(icon);
 
      if (icon && m_Entity.GetInventory().GetSlotLock(iw.GetUserID()))
        return;
 
      if (icon.IsOutOfReach())
        return;
 
      ItemBase item = ItemBase.Cast(iw.GetItem());
      if (item)
      {
        if (!item.GetInventory().CanRemoveEntity())
          return;
 
        PlayerBase controlledPlayer = PlayerBase.Cast(GetGame().GetPlayer());
        if (controlledPlayer.GetInventory().HasEntityInInventory(item) && controlledPlayer.GetHumanInventory().CanAddEntityInHands(item))
          controlledPlayer.PredictiveTakeEntityToHands(item);
        else
        {
          if (controlledPlayer.GetInventory().CanAddEntityToInventory(item) && item.GetInventory().CanRemoveEntity())
          {
            if (item.GetTargetQuantityMax() < item.GetQuantity())
              item.SplitIntoStackMaxClient(controlledPlayer, -1);
            else
              controlledPlayer.PredictiveTakeEntityToInventory(FindInventoryLocationType.ANY, item);
          }
          else
          {
            if (controlledPlayer.GetHumanInventory().CanAddEntityInHands(item))
            {
              if (item.GetTargetQuantityMax() < item.GetQuantity())
                item.SplitIntoStackMaxHandsClient(controlledPlayer);
              else
                controlledPlayer.PredictiveTakeEntityToHands(item);
            }
          }
        }
 
        HideOwnedTooltip();
 
        name = w.GetName();
        name.Replace("PanelWidget", "Temperature");
        w.FindAnyWidget(name).Show(false);
      }
    }
  }

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

DraggingOverGrid()

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

inlineprotected

Definition at line 469 of file AttachmentCategoriesRow.c.

  {
    if (w == null)
      return false;
 
    EntityAI item = GetItemPreviewItem(w);
 
    if (!item)
      return false;
 
    int color;
    int idx = 0;
    int c_x, c_y;
 
    EntityAI target_entity;
    CargoBase target_cargo;
 
    target_entity = cargo.GetEntity() ;
    if (target_entity)
      target_cargo = target_entity.GetInventory().GetCargo();
    else
      return false;
 
    if (target_cargo && target_entity)
    {
      c_x = target_cargo.GetHeight();
      c_y = target_cargo.GetWidth();
    }
    else
      return false;
 
    if (c_x > x && c_y > y && target_entity.GetInventory().CanAddEntityInCargoEx(item, idx, x, y, item.GetInventory().GetFlipCargo()))
      color = ColorManager.GREEN_COLOR;
    else
      color = ColorManager.RED_COLOR;
 
    if (w.FindAnyWidget("Cursor"))
      w.FindAnyWidget("Cursor").SetColor(color);
    else
    {
      string name = w.GetName();
      name.Replace("PanelWidget", "Cursor");
      if (w.FindAnyWidget(name))
        w.FindAnyWidget(name).SetColor(color);
    }
 
    return true;
  }

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

DraggingOverHeader()

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

inlineprotected

Definition at line 395 of file AttachmentCategoriesRow.c.

  {
    if (w == null)
      return;
    ItemPreviewWidget iw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
    if (!iw)
    {
      string name = w.GetName();
      name.Replace("PanelWidget", "Render");
      iw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
    }
    if (!iw)
      iw = ItemPreviewWidget.Cast(w);
 
    if (!iw || !iw.GetItem() || (iw.GetItem() == m_Entity))
      return;
 
    ItemBase item;
    ItemBase receiver_item;
    name = receiver.GetName();
    name.Replace("PanelWidget", "Render");
    ItemPreviewWidget receiver_iw = ItemPreviewWidget.Cast(receiver.FindAnyWidget(name));
    if (receiver_iw)
      receiver_item = ItemBase.Cast(receiver_iw.GetItem());
 
    SlotsIcon slots_icon;
    receiver.GetUserData(slots_icon);
 
    if (receiver_item)
    {
      int stack_max = InventorySlots.GetStackMaxForSlotId(receiver_item.GetInventory().GetSlotId(0));
      //int quantity = receiver_item.GetQuantity();
      //bool combinable = ( quantity < stack_max ) && ( ItemBase.Cast( receiver_item ).CanBeCombined( ItemBase.Cast( iw.GetItem() ) ) );
      if (receiver_item.CanBeCombined(ItemBase.Cast(iw.GetItem())))
      {
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetLeftDropzone().SetAlpha(1);
        ColorManager.GetInstance().SetColor(w, ColorManager.COMBINE_COLOR);
      }
      else if (stack_max == 0 && GameInventory.CanSwapEntitiesEx(receiver_item, iw.GetItem()))
      {
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetLeftDropzone().SetAlpha(1);
        ColorManager.GetInstance().SetColor(w, ColorManager.SWAP_COLOR);
      }
      else
      {
        ItemManager.GetInstance().ShowSourceDropzone(iw.GetItem());
        ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
      }
    }
    else if (slots_icon && slots_icon.GetSlotID() != -1)
    {
      item = ItemBase.Cast(iw.GetItem());
 
      if (item && m_Entity.GetInventory().CanAddAttachmentEx(item, slots_icon.GetSlotID()))
      {
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().GetLeftDropzone().SetAlpha(1);
        ColorManager.GetInstance().SetColor(w, ColorManager.GREEN_COLOR);
      }
      else
      {
        ItemManager.GetInstance().ShowSourceDropzone(iw.GetItem());
        ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
      }
    }
    else
    {
      ItemManager.GetInstance().ShowSourceDropzone(iw.GetItem());
      ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
    }
  }

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

DropReceived()

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

inlineprotected

Definition at line 518 of file AttachmentCategoriesRow.c.

  {
    EntityAI item = GetItemPreviewItem(w);
    if (!item)
      return;
 
    int idx = 0;
    int c_x, c_y;
 
    EntityAI target_entity;
    CargoBase target_cargo;
 
    target_entity = cargo.GetEntity();
    if (target_entity)
      target_cargo = target_entity.GetInventory().GetCargo();
    else
      return;
 
    if (target_cargo && target_entity)
    {
      c_x = target_cargo.GetHeight();
      c_y = target_cargo.GetWidth();
    }
    else
      return;
 
    InventoryLocation dst = new InventoryLocation;
    dst.SetCargoAuto(target_cargo, item, x, y, item.GetInventory().GetFlipCargo());
 
    if (c_x > x && c_y > y && target_entity.GetInventory().LocationCanAddEntity(dst))
    {
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
      SplitItemUtils.TakeOrSplitToInventoryLocation(player, dst);
 
      Icon icon = cargo.GetIcon(item);
 
      if (icon)
      {
        icon.GetCursorWidget().SetColor(ColorManager.BASE_COLOR);
        icon.RefreshPos(x, y);
        icon.Refresh();
        Refresh();
      }
    }
  }

References ColorManager::BASE_COLOR, GetGame(), GetItemPreviewItem(), GetPlayer(), Refresh(), SplitItemUtils::TakeOrSplitToInventoryLocation(), x, and y.

EquipItem()

override bool AttachmentCategoriesRow::EquipItem ( )

inlineprotected

Definition at line 237 of file AttachmentCategoriesRow.c.

  {
    return false;
  }

GetCategoryIdentifier()

string AttachmentCategoriesRow::GetCategoryIdentifier ( )

inlineprotected

Definition at line 23 of file AttachmentCategoriesRow.c.

  {
    return m_CategoryIdentifier;
  }

References m_CategoryIdentifier.

GetFocusedSlot()

int AttachmentCategoriesRow::GetFocusedSlot ( )

inlineprotected

Definition at line 28 of file AttachmentCategoriesRow.c.

  {
    SlotsIcon icon = GetFocusedSlotsIcon();
    if (icon)
      return icon.GetSlotID();
    return -1;
  }

Referenced by CanCombine(), and Combine().

GetItemPreviewItem()

EntityAI AttachmentCategoriesRow::GetItemPreviewItem ( Widget w )

inlineprotected

Definition at line 565 of file AttachmentCategoriesRow.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 || !ipw.IsInherited(ItemPreviewWidget))
      return null;
    return ipw.GetItem();
  }

References name.

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

Init()

void AttachmentCategoriesRow::Init ( int attachments_categories_count, int i, string attachment_category, string config_path_attachment_categories, EntityAI entity, int parent_m_Body_count )

inlineprotected

Definition at line 823 of file AttachmentCategoriesRow.c.

  {
    m_Entity = entity;
    Header header = GetHeader();
 
    m_CategoryIdentifier = attachment_category;
 
    array<string> player_ghosts_slots2 = new array<string>();
    string categoryName;
 
    m_RowConfigPath = config_path_attachment_categories + " " + attachment_category + " attachmentSlots";
    string config_path_category_name = config_path_attachment_categories + " " + attachment_category + " name";
    GetGame().ConfigGetTextArray(m_RowConfigPath, player_ghosts_slots2);
    GetGame().ConfigGetText(config_path_category_name, categoryName);
    header.SetName(categoryName);
 
    m_AttachmentsContainer.SetHeader(header);
    SetHeader(null);
 
    int count = player_ghosts_slots2.Count();
    int lastRow = count / ITEMS_IN_ROW;
    SlotsContainer slotsContainer;
 
    for (int j = 0; j < count; j++)
    {
      string slotName = player_ghosts_slots2.Get(j);
      string iconName; //must be in format "set:<setname> image:<imagename>"
      string path = "CfgSlots" + " Slot_" + slotName;
 
      int slotId = InventorySlots.GetSlotIdFromString(slotName);
 
      GetGame().ConfigGetText(path + " ghostIcon", iconName);
      GetGame().ConfigGetText(path + " name", slotName);
 
      int row = j / ITEMS_IN_ROW;
      int column = j % ITEMS_IN_ROW;
      if (column == 0)
      {
        slotsContainer = new SlotsContainer(m_AttachmentsContainer, m_Entity);
        slotsContainer.GetRootWidget().SetAlpha(0.7);
        if (row == lastRow)
          slotsContainer.SetColumnCount(count % ITEMS_IN_ROW);
        else
          slotsContainer.SetColumnCount(ITEMS_IN_ROW);
 
        m_AttachmentsContainer.Insert(slotsContainer);
        slotsContainer.GetRootWidget().SetSort(row);
      }
 
      SlotsIcon icon = slotsContainer.GetSlotIcon(column);
      WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetMainWidget(), this, "OnDropReceivedFromHeader");
      WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetGhostSlot(), this, "OnDropReceivedFromHeader");
      WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetPanelWidget(), this, "OnDropReceivedFromHeader");
 
      WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetMainWidget(), this, "DraggingOverHeader");
      WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetGhostSlot(), this, "DraggingOverHeader");
      WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetPanelWidget(), this, "DraggingOverHeader");
 
      WidgetEventHandler.GetInstance().RegisterOnDrop(icon.GetMainWidget(), this, "OnIconDrop");
      WidgetEventHandler.GetInstance().RegisterOnDrop(icon.GetPanelWidget(), this, "OnIconDrop");
 
      WidgetEventHandler.GetInstance().RegisterOnDoubleClick(icon.GetPanelWidget(), this, "DoubleClick");
      WidgetEventHandler.GetInstance().RegisterOnMouseButtonUp(icon.GetPanelWidget(), this, "MouseClick");
 
      icon.GetGhostSlot().LoadImageFile(0, StaticGUIUtils.VerifyIconImageString(StaticGUIUtils.IMAGESETGROUP_INVENTORY, iconName));
      icon.SetSlotID(slotId);
      icon.SetSlotDisplayName(InventorySlots.GetSlotDisplayName(slotId));
 
      icon.Clear();
    }
    RefreshAllSlots();
  }

References GetGame(), GetHeader(), WidgetEventHandler::GetInstance(), InventorySlots::GetSlotDisplayName(), InventorySlots::GetSlotIdFromString(), StaticGUIUtils::IMAGESETGROUP_INVENTORY, ITEMS_IN_ROW, m_AttachmentsContainer, m_CategoryIdentifier, m_Entity, m_RowConfigPath, path, RefreshAllSlots(), slotName, and StaticGUIUtils::VerifyIconImageString().

IsItemActive()

override bool AttachmentCategoriesRow::IsItemActive ( )

inlineprotected

Definition at line 286 of file AttachmentCategoriesRow.c.

  {
    SlotsIcon icon = GetFocusedSlotsIcon();
    return GetFocusedItem() != null && (!icon || !icon.IsOutOfReach());
  }

IsItemWithQuantityActive()

override bool AttachmentCategoriesRow::IsItemWithQuantityActive ( )

inlineprotected

Definition at line 292 of file AttachmentCategoriesRow.c.

  {
    ItemBase item = ItemBase.Cast(GetFocusedItem());
    SlotsIcon icon = GetFocusedSlotsIcon();
    return item && (!icon || !icon.IsOutOfReach()) && item.CanBeSplit();
  }

MouseClick()

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

inlineprotected

Definition at line 767 of file AttachmentCategoriesRow.c.

  {
    ItemBase selectedItem;
    SlotsIcon icon;
    w.GetUserData(icon);
    if (icon)
      selectedItem = ItemBase.Cast(icon.GetEntity());
 
    if (selectedItem)
    {
      switch (button)
      {
      case MouseState.RIGHT:
#ifdef DIAG_DEVELOPER
        if (g_Game.IsLeftCtrlDown())
          ShowActionMenu(selectedItem);
#endif
 
        break;
 
      case MouseState.MIDDLE:
        InspectItem(selectedItem);
        break;
 
      case MouseState.LEFT:
        PlayerBase controlledPlayer = PlayerBase.Cast(GetGame().GetPlayer());
        if (g_Game.IsLeftCtrlDown())
        {
          if (icon.IsOutOfReach())
            return;
 
          if (controlledPlayer.CanDropEntity(selectedItem))
          {
            if (selectedItem.GetTargetQuantityMax() < selectedItem.GetQuantity())
              selectedItem.SplitIntoStackMaxClient(null, -1);
            else
              controlledPlayer.PhysicalPredictiveDropItem(selectedItem);
          }
          else
          {
            bool draggable = !controlledPlayer.GetInventory().HasInventoryReservation(selectedItem, null) && !controlledPlayer.GetInventory().IsInventoryLocked() && selectedItem.GetInventory().CanRemoveEntity() && !controlledPlayer.IsItemsToDelete();
            ItemManager.GetInstance().SetWidgetDraggable(w, draggable);
          }
        }
        else
        {
          ClosableContainer c = ClosableContainer.Cast(icon.GetContainer());
          if (c)
            c.Toggle();
        }
 
        break;
      }
    }
  }

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

OnDropReceivedFromHeader()

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

inlineprotected

Definition at line 299 of file AttachmentCategoriesRow.c.

  {
    ItemManager.GetInstance().HideDropzones();
    ItemManager.GetInstance().SetIsDragging(false);
    SlotsIcon slots_icon;
    EntityAI receiver_item;
    int slot_id = -1;
    bool is_reserved = false;
    EntityAI attached_entity;
    receiver.GetUserData(slots_icon);
    float stackable = 0.0;
    InventoryLocation il = new InventoryLocation;
 
    if (slots_icon)
    {
      receiver_item = slots_icon.GetEntity();
      slot_id = slots_icon.GetSlotID();
      attached_entity = slots_icon.GetSlotParent();
      is_reserved = slots_icon.IsReserved();
    }
 
    EntityAI item = GetItemPreviewItem(w);
    if (!item)
      return;
    ItemBase item_base = ItemBase.Cast(item);
 
    PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
    if (!item.GetInventory().CanRemoveEntity() || !player.CanManipulateInventory())
      return;
 
    EntityAI target_att_entity = m_Entity;
    Weapon_Base wpn;
    Magazine mag;
    if (Class.CastTo(wpn, m_Entity) && Class.CastTo(mag, item))
    {
      if (player.GetWeaponManager().CanAttachMagazine(wpn, mag))
        player.GetWeaponManager().AttachMagazine(mag);
    }
    else if (receiver_item && !is_reserved)
    {
      if ((ItemBase.Cast(receiver_item)).CanBeCombined(ItemBase.Cast(item)))
        (ItemBase.Cast(receiver_item)).CombineItemsClient(ItemBase.Cast(item));
      else if (GameInventory.CanSwapEntitiesEx(receiver_item, item))
      {
        if (!receiver_item.GetInventory().CanRemoveEntity())
          return;
        GetGame().GetPlayer().PredictiveSwapEntities(receiver_item, item);
      }
      else if (receiver_item.GetInventory().CanAddAttachment(item))
        player.PredictiveTakeEntityToTargetAttachment(receiver_item, item);
    }
    else if (attached_entity && slot_id != -1 && attached_entity.GetInventory().CanAddAttachmentEx(item, slot_id))
    {
      item_base = ItemBase.Cast(item);
      stackable = item_base.GetTargetQuantityMax(slot_id);
 
      if (stackable == 0 || stackable >= item_base.GetQuantity())
        player.PredictiveTakeEntityToTargetAttachmentEx(attached_entity, item, slot_id);
      else if (stackable != 0 && stackable < item_base.GetQuantity())
        item_base.SplitIntoStackMaxClient(m_Entity, slot_id);
    }
    else if (attached_entity && slot_id == -1 && attached_entity.GetInventory().FindFreeLocationFor(item, FindInventoryLocationType.ATTACHMENT, il))
    {
      item_base = ItemBase.Cast(item);
      stackable = item_base.GetTargetQuantityMax(il.GetSlot());
 
      if (stackable == 0 || stackable >= item_base.GetQuantity())
        player.PredictiveTakeEntityToTargetAttachmentEx(attached_entity, item, il.GetSlot());
      else if (stackable != 0 && stackable < item_base.GetQuantity())
        item_base.SplitIntoStackMaxClient(m_Entity, il.GetSlot());
    }
    /*else if( ( m_Entity.GetInventory().CanAddEntityInCargo( item, item.GetInventory().GetFlipCargo() ) && ( !player.GetInventory().HasEntityInInventory( item ) || !m_Entity.GetInventory().HasEntityInCargo( item )) ) )
      {
      SplitItemUtils.TakeOrSplitToInventory( PlayerBase.Cast( GetGame().GetPlayer() ), m_Entity, item );
      }*/
  }

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

Refresh()

override void AttachmentCategoriesRow::Refresh ( )

inlineprotected

Definition at line 581 of file AttachmentCategoriesRow.c.

  {
    if (!m_Refreshing)
    {
      if (!m_Closed)
      {
        super.Refresh();
        RefreshAllSlots();
      }
    }
  }

References m_Refreshing, and RefreshAllSlots().

Referenced by DropReceived().

RefreshAllSlots()

void AttachmentCategoriesRow::RefreshAllSlots ( )

inlineprotected

Definition at line 593 of file AttachmentCategoriesRow.c.

  {
    m_Refreshing = true;
    int row_count = m_AttachmentsContainer.GetRowCount();
    int row;
    for (row = 0; row < row_count; row++)
    {
      int col_count = m_AttachmentsContainer.GetColumnCountForRow(row);
      int col;
      for (col = 0; col < col_count; col++)
        RefreshSlot(row, col, -1, "");
    }
    m_Refreshing = false;
  }

References m_AttachmentsContainer, m_Refreshing, and RefreshSlot().

Referenced by Init(), Refresh(), and UpdateInterval().

RefreshSlot()

void AttachmentCategoriesRow::RefreshSlot ( int row, int column, int slot_id, string slot_name )

inlineprotected

Definition at line 609 of file AttachmentCategoriesRow.c.

  {
    SlotsIcon icon = m_AttachmentsContainer.GetSlotsIcon(row, column);
    int slot_id_ = icon.GetSlotID();
    EntityAI item = m_Entity.GetInventory().FindAttachment(slot_id_);
    ContainerWithCargo cont;
 
    if (!m_Entity.CanDisplayAttachmentSlot(slot_id_))
    {
      icon.Clear();
      icon.GetMainWidget().Show(false);
    }
    else if (!item)
    {
      if (icon.GetEntity())
      {
        icon.ClearRemainSelected();
 
        cont = m_AttachmentCargos.Get(slot_id_);
        if (cont)
        {
          m_AttachmentCargos.Remove(slot_id_);
          this.Remove(cont);
          (Container.Cast(cont.m_Parent)).Remove(cont);
        }
      }
      icon.GetMainWidget().Show(true);
    }
    else
    {
      icon.GetMainWidget().Show(true);
      if (icon.GetEntity() != item)
        icon.Init(item);
      else
        icon.Refresh();
 
      cont = m_AttachmentCargos.Get(slot_id_);
      if (cont && cont.GetEntity() != item)
      {
        m_AttachmentCargos.Remove(slot_id_);
        (Container.Cast(cont.m_Parent)).Remove(cont);
        this.Remove(cont);
        cont = null;
      }
 
      if (!cont)
      {
        if (item.GetInventory().GetCargo() && m_AttachmentCargos)
        {
          cont = new ContainerWithCargo(this, true);
          cont.GetRootWidget().SetSort(m_AttachmentCargos.Count() + 10);
          cont.SetEntity(item);
          cont.SetSlotIcon(icon);
 
          m_AttachmentCargos.Insert(slot_id_, cont);
          icon.SetContainer(cont);
 
          SetOpenForSlotIcon(cont.IsOpened(), icon);
        }
      }
 
      if (cont)
        icon.GetRadialIconPanel().Show(cont.IsDisplayable());
 
      string slot_name_ = InventorySlots.GetSlotName(slot_id_);
      bool draggable = true;
      bool can_be_removed = item.GetInventory().CanRemoveEntity();
      bool in_hands_condition = m_Entity.GetHierarchyRoot() == GetGame().GetPlayer();
      bool in_vicinity_condition = AttachmentsOutOfReach.IsAttachmentReachable(m_Entity, slot_name_);
      if (m_Entity.GetInventory().GetSlotLock(slot_id_) && ItemManager.GetInstance().GetDraggedItem() != item)
      {
        icon.GetMountedWidget().Show(true);
        draggable = false;
      }
      else
        icon.GetMountedWidget().Show(false);
 
      if (!m_Entity.CanReleaseAttachment(item))
        draggable = false;
 
      if ((in_hands_condition || in_vicinity_condition) && can_be_removed)
        icon.GetOutOfReachWidget().Show(false);
      else
      {
        icon.GetOutOfReachWidget().Show(true);
        draggable = false;
      }
 
      if (draggable)
        icon.GetRender().GetParent().SetFlags(WidgetFlags.DRAGGABLE);
      else
        icon.GetRender().GetParent().ClearFlags(WidgetFlags.DRAGGABLE);
    }
  }

References ClosableContainer::ContainerWithCargo(), GetGame(), ItemManager::GetInstance(), InventorySlots::GetSlotName(), AttachmentsOutOfReach::IsAttachmentReachable(), m_AttachmentCargos, m_AttachmentsContainer, m_Entity, and Remove().

Referenced by RefreshAllSlots().

Select()

override bool AttachmentCategoriesRow::Select ( )

inlineprotected

Definition at line 36 of file AttachmentCategoriesRow.c.

  {
    Man player = GetGame().GetPlayer();
    SlotsIcon focused_icon = GetFocusedSlotsIcon();
    EntityAI focused_item = GetFocusedItem();
    Container focused_cont = GetFocusedContainer();
    ItemBase selected_item = ItemBase.Cast(ItemManager.GetInstance().GetSelectedItem()); // == dragged item
 
    if (selected_item && focused_item != selected_item)//dropping from micromanagement
    {
      if (selected_item.GetInventory().CanRemoveEntity())
      {
        int stack_max;
 
        if (!focused_icon)
        {
          if (focused_cont)
            focused_cont.Select();
        }
        else if (!focused_item && m_Entity && m_Entity.GetInventory().CanAddAttachmentEx(selected_item, focused_icon.GetSlotID()))
        {
          stack_max = InventorySlots.GetStackMaxForSlotId(focused_icon.GetSlotID());
          float quantity = selected_item.GetQuantity();
          if (stack_max == 0 || stack_max >= quantity || !selected_item.CanBeSplit())
          {
            player.PredictiveTakeEntityToTargetAttachmentEx(m_Entity, selected_item, focused_icon.GetSlotID());
            return true;
          }
          else
          {
            selected_item.SplitIntoStackMaxClient(m_Entity, focused_icon.GetSlotID());
            return true;
          }
        }
        else if (focused_icon.GetSlotID() != -1)
        {
          if (focused_item && focused_item.GetHierarchyParent() && focused_item.GetHierarchyParent().GetInventory().CanAddAttachment(selected_item))
          {
            InventoryLocation inv_loc = new InventoryLocation;
            focused_item.GetInventory().GetCurrentInventoryLocation(inv_loc);
            stack_max = InventorySlots.GetStackMaxForSlotId(inv_loc.GetSlot());
            quantity = focused_item.GetQuantity();
            if (focused_item.CanBeCombined(ItemBase.Cast(selected_item)))
            {
              focused_item.CombineItemsClient(selected_item, true);
              return true;
            }
            else if (stack_max == 0 && GameInventory.CanSwapEntitiesEx(focused_item, selected_item))
            {
              player.PredictiveSwapEntities(selected_item, focused_item);
              return true;
            }
            else if (m_AttachmentCargos.Contains(inv_loc.GetSlot()))
            {
              if (focused_item.GetInventory().CanAddEntityInCargo(selected_item, selected_item.GetInventory().GetFlipCargo()))
              {
                SplitItemUtils.TakeOrSplitToInventory(PlayerBase.Cast(player), focused_item, selected_item);
                return true;
              }
            }
          }
        }
      }
    }
    else //clicking
    {
      if (focused_item && focused_item.GetInventory().CanRemoveEntity() && (!focused_icon || !focused_icon.IsOutOfReach()))
      {
        EntityAI item_in_hands = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
        if (item_in_hands && item_in_hands.GetInventory().CanRemoveEntity())
        {
          if (GameInventory.CanSwapEntitiesEx(item_in_hands, focused_item))
          {
            player.PredictiveSwapEntities(item_in_hands, focused_item);
            return true;
          }
        }
        else
        {
          if (player.GetHumanInventory().CanAddEntityInHands(focused_item))
          {
            player.PredictiveTakeEntityToHands(focused_item);
            return true;
          }
        }
      }
    }
 
    return false;
  }

References GameInventory::CanSwapEntitiesEx(), GetGame(), ItemManager::GetInstance(), InventorySlots::GetStackMaxForSlotId(), m_AttachmentCargos, m_Entity, and SplitItemUtils::TakeOrSplitToInventory().

SplitItem()

override bool AttachmentCategoriesRow::SplitItem ( )

inlineprotected

Definition at line 232 of file AttachmentCategoriesRow.c.

  {
    return false;
  }

TransferItem()

override bool AttachmentCategoriesRow::TransferItem ( )

inlineprotected

Definition at line 127 of file AttachmentCategoriesRow.c.

  {
    if (CanTakeToInventory())
    {
      EntityAI entity = GetFocusedItem();
      SlotsIcon focused_icon = GetFocusedSlotsIcon();
      if (entity && !entity.IsLockedInSlot() && (!focused_icon || !focused_icon.IsOutOfReach()))
      {
        PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
        GetGame().GetPlayer().PredictiveTakeEntityToInventory(FindInventoryLocationType.CARGO, entity);
        return true;
      }
    }
    return false;
  }

References GetGame(), and GetPlayer().

TransferItemToVicinity()

override bool AttachmentCategoriesRow::TransferItemToVicinity ( )

inlineprotected

Definition at line 143 of file AttachmentCategoriesRow.c.

  {
    if (CanDrop())
    {
      ItemBase item = ItemBase.Cast(GetFocusedItem());
      PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
      SlotsIcon focused_icon = GetFocusedSlotsIcon();
 
      if (item && !item.IsLockedInSlot() && (focused_icon && !focused_icon.IsOutOfReach()))
      {
        if (item.GetTargetQuantityMax() < item.GetQuantity())
          item.SplitIntoStackMaxClient(null, -1);
        else
          player.PhysicalPredictiveDropItem(item);
        return true;
      }
    }
    return false;
  }

References GetGame(), and GetPlayer().

UnfocusAll()

override void AttachmentCategoriesRow::UnfocusAll ( )

inlineprotected

Definition at line 376 of file AttachmentCategoriesRow.c.

  {
    int i;
    for (i = 1; i < Count(); i++)
    {
      for (int j = 0; j < ITEMS_IN_ROW; j++)
      {
        Widget w = Get(i).GetMainWidget().FindAnyWidget("Cursor" + j);
        if (w)
          w.Show(false);
      }
    }
    for (i = 0; i < m_AttachmentCargos.Count(); i++)
    {
      m_AttachmentCargos.GetElement(i).Unfocus();
      m_AttachmentCargos.GetElement(i).SetActive(false);
    }
  }

References Count, Get(), ITEMS_IN_ROW, and m_AttachmentCargos.

UpdateInterval()

override void AttachmentCategoriesRow::UpdateInterval ( )

inlineprotected

Definition at line 896 of file AttachmentCategoriesRow.c.

  {
    super.UpdateInterval();
    RefreshAllSlots();
  }

References RefreshAllSlots().

Member Data Documentation

m_AttachmentCargos

ref map<int, ref ContainerWithCargo> AttachmentCategoriesRow::m_AttachmentCargos

protected

Definition at line 8 of file AttachmentCategoriesRow.c.

Referenced by AttachmentCategoriesRow(), Combine(), RefreshSlot(), Select(), and UnfocusAll().

m_AttachmentsContainer

ref AttachmentsGroupContainer AttachmentCategoriesRow::m_AttachmentsContainer

protected

Definition at line 7 of file AttachmentCategoriesRow.c.

Referenced by AttachmentCategoriesRow(), Init(), RefreshAllSlots(), and RefreshSlot().

m_CategoryIdentifier

string AttachmentCategoriesRow::m_CategoryIdentifier

protected

Definition at line 3 of file AttachmentCategoriesRow.c.

Referenced by GetCategoryIdentifier(), and Init().

m_Refreshing

bool AttachmentCategoriesRow::m_Refreshing

protected

Definition at line 5 of file AttachmentCategoriesRow.c.

Referenced by AttachmentCategoriesRow(), Refresh(), and RefreshAllSlots().

m_RowConfigPath

string AttachmentCategoriesRow::m_RowConfigPath

protected

Definition at line 4 of file AttachmentCategoriesRow.c.

Referenced by Init().

---

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

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