slotsicon.c

Go to the documentation of this file.

class SlotsIcon: LayoutHolder
{
 protected static int m_NormalWidth;
 protected static int m_NormalHeight;
 
 protected bool m_IsWeapon = false;
 protected bool m_IsMagazine = false;
 protected bool m_HasTemperature = false;
 protected bool m_HasQuantity = false;
 protected bool m_HasItemSize = false;
 protected float m_CurrQuantity = -1;
 
 protected EntityAI m_Obj;
 protected ItemBase m_Item;
 protected EntityAI m_SlotParent;
 protected Container m_Container;
 protected int m_SlotID;
 protected bool m_IsDragged = false;
 
 protected Widget m_PanelWidget;
 
 protected Widget m_CursorWidget;
 protected Widget m_ColWidget;
 protected Widget m_MountedWidget;
 protected Widget m_OutOfReachWidget;
 protected Widget m_ReservedWidget;
 
 protected ItemPreviewWidget m_ItemPreview;
 protected ImageWidget m_GhostSlot;
 
 protected Widget m_ColorWidget;
 protected Widget m_SelectedPanel;
 protected Widget m_EmptySelectedPanel;
 protected Widget m_MicromanagedPanel;
 
 protected Widget m_QuantityPanel;
 protected TextWidget m_QuantityItem;
 protected ProgressBarWidget m_QuantityProgress;
 protected Widget m_QuantityStack;
 
 protected string m_SlotDisplayName;
 protected string m_SlotDesc;
 
 protected Widget m_ItemSizePanel;
 protected TextWidget m_ItemSizeWidget;
 
 protected Widget m_AmmoIcon;
 
 protected Widget m_RadialIconPanel;
 protected Widget m_RadialIconClosed;
 protected Widget m_RadialIcon;
 
 protected bool m_Reserved;
 
 void SlotsIcon( LayoutHolder parent, Widget root, int index, EntityAI slot_parent )
 {
 m_MainWidget = root;
 
 m_PanelWidget = m_MainWidget.FindAnyWidget( "PanelWidget" + index );
 
 m_CursorWidget = m_MainWidget.FindAnyWidget( "Cursor" + index );
 m_ColWidget = m_MainWidget.FindAnyWidget( "Col" + index );
 m_MountedWidget = m_MainWidget.FindAnyWidget( "Mounted" + index );
 m_OutOfReachWidget = m_MainWidget.FindAnyWidget( "OutOfReach" + index );
 
 m_ItemPreview = ItemPreviewWidget.Cast( m_MainWidget.FindAnyWidget( "Render" + index ) );
 m_ItemPreview.SetForceFlipEnable(true);
 m_ItemPreview.SetForceFlip(false);
 
 m_GhostSlot = ImageWidget.Cast( m_MainWidget.FindAnyWidget( "GhostSlot" + index ) );
 
 m_ColorWidget = m_MainWidget.FindAnyWidget( "Color" + index );
 m_SelectedPanel = m_MainWidget.FindAnyWidget( "Selected" + index );
 m_EmptySelectedPanel = m_MainWidget.FindAnyWidget( "EmptySelected" + index );
 m_MicromanagedPanel = m_MainWidget.FindAnyWidget( "Micromanaged" + index );
 
 m_QuantityPanel = m_MainWidget.FindAnyWidget( "QuantityPanel" + index );
 m_QuantityItem = TextWidget.Cast( m_MainWidget.FindAnyWidget( "Quantity" + index ) );
 m_QuantityProgress = ProgressBarWidget.Cast( m_MainWidget.FindAnyWidget( "QuantityBar" + index ) );
 m_QuantityStack = m_MainWidget.FindAnyWidget( "QuantityStackPanel" + index );
 
 m_ItemSizePanel = m_MainWidget.FindAnyWidget( "ItemSizePanel" + index );
 m_ItemSizeWidget = TextWidget.Cast( m_MainWidget.FindAnyWidget( "ItemSize" + index ) );
 
 m_AmmoIcon = m_MainWidget.FindAnyWidget( "AmmoIcon" + index );
 
 m_RadialIconPanel = m_MainWidget.FindAnyWidget( "RadialIconPanel" + index );
 m_RadialIconClosed = m_MainWidget.FindAnyWidget( "RadialIconClosed" + index );
 m_RadialIcon = m_MainWidget.FindAnyWidget( "RadialIcon" + index );
 
 m_ReservedWidget = Widget.Cast( GetGame().GetWorkspace().CreateWidgets( "gui/layouts/inventory_new/reserved_icon.layout", m_MainWidget ) );
 m_ReservedWidget.Show(false);
 
 WidgetEventHandler.GetInstance().RegisterOnMouseEnter( m_PanelWidget, this, "MouseEnter" );
 WidgetEventHandler.GetInstance().RegisterOnMouseLeave( m_PanelWidget, this, "MouseLeave" );
 
 WidgetEventHandler.GetInstance().RegisterOnMouseEnter( m_GhostSlot, this, "MouseEnterGhostSlot" );
 WidgetEventHandler.GetInstance().RegisterOnMouseLeave( m_GhostSlot, this, "MouseLeaveGhostSlot" );
 
 WidgetEventHandler.GetInstance().RegisterOnMouseEnter( m_RadialIconPanel, this, "MouseEnterCategory" );
 WidgetEventHandler.GetInstance().RegisterOnMouseLeave( m_RadialIconPanel, this, "MouseLeaveCategory" );
 
 WidgetEventHandler.GetInstance().RegisterOnDrag( m_PanelWidget, this, "OnIconDrag" );
 WidgetEventHandler.GetInstance().RegisterOnDrop( m_PanelWidget, this, "OnIconDrop" );
 
 //WidgetEventHandler.GetInstance().RegisterOnMouseEnter( m_ReservedWidget, this, "MouseEnter" );
 //WidgetEventHandler.GetInstance().RegisterOnMouseLeave( m_ReservedWidget, this, "MouseLeave" );
 
 m_Reserved = false;
 m_SlotID = -1;
 m_Item = null;
 m_Obj = null;
 m_Container = null;
 
 m_SlotParent = slot_parent;
 
 m_PanelWidget.SetUserData(this);
 m_ItemPreview.SetUserData(this);
 m_GhostSlot.SetUserData(this);
 m_MainWidget.SetUserData(this);
 
 float w,h;
 root.GetSize(w,h);
 
 m_NormalWidth = w;
 m_NormalHeight = h;
 
 SetActive( false );
 }
 
 override bool IsVisible()
 {
 return m_MainWidget.IsVisible();
 }
 
 void SetSlotParent( EntityAI parent)
 {
 m_SlotParent = parent;
 }
 
 void SetContainer( Container container )
 {
 m_Container = container;
 }
 
 void SetSlotDisplayName( string text )
 {
 m_SlotDisplayName = text;
 }
 
 Container GetContainer()
 {
 return m_Container;
 }
 
 string GetSlotDisplayName( )
 {
 return m_SlotDisplayName;
 }
 
 void SetSlotDesc( string text )
 {
 m_SlotDesc = text;
 }
 
 string GetSlotDesc()
 {
 return m_SlotDesc;
 }
 
 void ~SlotsIcon()
 {
 if (m_IsDragged)
 {
 m_IsDragged = false;
 ItemManager.GetInstance().HideDropzones();
 ItemManager.GetInstance().SetIsDragging( false );
 }
 
 if (m_Obj)
 {
 m_Obj.GetOnItemFlipped().Remove( UpdateFlip );
 m_Obj.GetOnViewIndexChanged().Remove( SetItemPreview );
 }
 }
 
 EntityAI GetSlotParent()
 {
 return m_SlotParent;
 }
 
 int GetSlotID()
 {
 return m_SlotID;
 }
 
 void SetSlotID(int slot_ID)
 {
 m_SlotID = slot_ID;
 }
 
 bool IsReserved()
 {
 return m_Reserved;
 }
 
 Widget GetPanelWidget()
 {
 return m_PanelWidget;
 }
 
 Widget GetCursorWidget()
 {
 return m_CursorWidget;
 }
 
 Widget GetColWidget()
 {
 return m_ColWidget;
 }
 
 Widget GetReservedWidget()
 {
 return m_ReservedWidget;
 }
 
 Widget GetMountedWidget()
 {
 return m_MountedWidget;
 }
 
 ItemPreviewWidget GetRender()
 {
 return m_ItemPreview;
 }
 
 ImageWidget GetGhostSlot()
 {
 return m_GhostSlot;
 }
 
 Widget GetColorWidget()
 {
 return m_ColorWidget;
 }
 
 Widget GetSelectedPanel()
 {
 return m_SelectedPanel;
 }
 
 Widget GetEmptySelectedPanel()
 {
 return m_EmptySelectedPanel;
 }
 
 Widget GetMicromanagedPanel()
 {
 return m_MicromanagedPanel;
 }
 
 Widget GetQuantityPanel()
 {
 return m_QuantityPanel;
 }
 
 Widget GetOutOfReachWidget()
 {
 return m_OutOfReachWidget;
 }
 
 TextWidget GetQuantityItem()
 {
 return m_QuantityItem;
 }
 
 ProgressBarWidget GetQuantityProgress()
 {
 return m_QuantityProgress;
 }
 
 Widget GetQuantityStack()
 {
 return m_QuantityStack;
 }
 
 Widget GetItemSizePanel()
 {
 return m_ItemSizePanel;
 }
 
 TextWidget GetItemSizeWidget()
 {
 return m_ItemSizeWidget;
 }
 
 Widget GetAmmoIcon()
 {
 return m_AmmoIcon;
 }
 
 Widget GetRadialIconPanel()
 {
 return m_RadialIconPanel;
 }
 
 Widget GetRadialIconClosed()
 {
 return m_RadialIconClosed;
 }
 
 Widget GetRadialIcon()
 {
 return m_RadialIcon;
 }
 
 bool IsFocused()
 {
 return GetCursorWidget().IsVisible();
 }
 
 override void SetActive( bool active )
 {
#ifdef PLATFORM_CONSOLE 
 super.SetActive( active );
 float x, y;
 if( active && GetObject() )
 {
 GetMainWidget().GetScreenPos( x, y );
 PrepareOwnedTooltip( EntityAI.Cast( GetObject() ), x, y );
 }
 else if (active)
 {
 GetMainWidget().GetScreenPos( x, y );
 PrepareOwnedSlotsTooltip( GetMainWidget(), m_SlotDisplayName, m_SlotDesc, x, y );
 }
 
 m_SelectedPanel.Show( active );
#endif
 }
 
 override void SetLayoutName()
 {
 m_LayoutName = "";
 }
 
 override void Refresh()
 {
 if( m_HasTemperature )
 SetTemperature();
 if( m_IsWeapon )
 RefreshMuzzleIcon();
 if( m_HasQuantity )
 SetQuantity();
 }
 
 void SetTemperature()
 {
 ItemManager.GetInstance().SetIconTemperature( EntityAI.Cast( m_Obj ), m_MainWidget );
 }
 
 Object GetObject()
 {
 return m_Obj;
 }
 
 EntityAI GetEntity()
 {
 return EntityAI.Cast( m_Obj );
 }
 
 ItemBase GetItem()
 {
 return m_Item;
 }
 
 void RefreshMuzzleIcon()
 {
 Weapon_Base wpn = Weapon_Base.Cast( GetObject() );
 if( wpn )
 {
 if( wpn.IsShowingChamberedBullet() )
 {
 int mi = wpn.GetCurrentMuzzle();
 m_AmmoIcon.Show( wpn.IsChamberFull( mi ) );
 
 }
 else
 {
 m_AmmoIcon.Show( false );
 }
 }
 }
 
 void SetQuantity()
 {
 if (m_Item)
 {
 int quantityType = QuantityConversions.HasItemQuantity(m_Item);
 if (quantityType != QUANTITY_HIDDEN && m_CurrQuantity != QuantityConversions.GetItemQuantity(m_Item))
 {
 m_CurrQuantity = QuantityConversions.GetItemQuantity(m_Item);
 
 if (quantityType == QUANTITY_COUNT)
 {
 string q_text = QuantityConversions.GetItemQuantityText(m_Item, true);
 
 if (QuantityConversions.GetItemQuantityMax(m_Item) == 1 || q_text == "")
 {
 m_QuantityStack.Show(false);
 }
 else
 {
 m_QuantityItem.SetText(q_text);
 m_QuantityStack.Show(true);
 }
 
 m_QuantityProgress.Show(false);
 }
 else if (quantityType == QUANTITY_PROGRESS)
 {
 float progress_max = m_QuantityProgress.GetMax();
 int max = m_Item.GetQuantityMax();
 int count = m_Item.ConfigGetInt("count");
 float quantity = m_CurrQuantity;
 
 if (count > 0)
 {
 max = count;
 }
 
 if (max > 0)
 {
 float value = Math.Round((quantity / max) * 100);
 m_QuantityProgress.SetCurrent(value);
 }
 m_QuantityStack.Show(false);
 m_QuantityProgress.Show(true);
 }
 }
 }
 }
 
 void SetItemPreview()
 {
 m_ItemPreview.Show( true );
 m_ItemPreview.SetItem( EntityAI.Cast( m_Obj ) );
 m_ItemPreview.SetModelOrientation( "0 0 0" );
 m_ItemPreview.SetView( m_Obj.GetViewIndex() );
 }
 
 void SetItemSize()
 {
 if( m_HasItemSize )
 {
 int size_x, size_y;
 GetGame().GetInventoryItemSize( InventoryItem.Cast( m_Obj ), size_x, size_y );
 
 m_ItemSizePanel.Show( true );
 m_ItemSizeWidget.SetText( ( size_x * size_y ).ToString() );
 }
 }
 
 void UpdateFlip( bool flipped )
 {
 if( !m_Reserved )
 {
 float x_content, y_content;
 GetPanelWidget().GetScreenSize( x_content, y_content );
 GetPanelWidget().SetSize( y_content, x_content );
 }
 }
 
 void Init( EntityAI obj, bool reservation = false )
 {
 if( m_Obj != obj )
 {
 ClearRemainSelected();
 m_Obj = obj;
 m_Item = ItemBase.Cast( m_Obj );
 m_Obj.GetOnItemFlipped().Insert( UpdateFlip );
 m_Obj.GetOnViewIndexChanged().Insert( SetItemPreview );
 m_Reserved = reservation;
 m_Container = null;
 
 if(reservation)
 {
 ItemManager.GetInstance().SetWidgetDraggable( m_PanelWidget, false );
 
 m_IsWeapon = false;
 m_IsMagazine = false;
 m_HasTemperature = false;
 m_HasQuantity = false;
 m_HasItemSize = false;
 }
 else
 {
 CheckIsWeapon();
 CheckIsMagazine();
 CheckHasTemperature();
 CheckHasQuantity();
 CheckHasItemSize();
 }
 
 m_ReservedWidget.Show(reservation);
 
 SetItemPreview();
 
 m_GhostSlot.Show( false );
 m_PanelWidget.Show( true );
 
 Refresh();
#ifdef PLATFORM_CONSOLE 
 if ( IsFocused() )
 {
 Inventory.GetInstance().UpdateConsoleToolbar();
 }
#endif
 }
 }
 
 void ClearRemainSelected()
 {
 if (m_IsDragged)
 {
 OnIconDrop(m_PanelWidget);
 Widget a = CancelWidgetDragging();
 ItemManager.GetInstance().SetWidgetDraggable( a, false );
 }
 if (m_Obj)
 {
 m_Obj.GetOnItemFlipped().Remove( UpdateFlip );
 m_Obj.GetOnViewIndexChanged().Remove( SetItemPreview );
 HideOwnedTooltip();
 }
 
 m_Obj = null;
 m_Item = null;
 m_Container = null;
 
 m_ItemPreview.Show( false );
 m_ItemPreview.SetItem( null );
 
 m_CurrQuantity = -1;
 m_IsWeapon = false;
 m_IsMagazine = false;
 m_HasTemperature = false;
 m_HasQuantity = false;
 m_HasItemSize = false;
 
 m_GhostSlot.Show( true );
 m_AmmoIcon.Show( false );
 m_PanelWidget.Show( false );
 m_RadialIconPanel.Show( false );
 
 m_QuantityPanel.Show( false );
 if(GetSlotID() != -1)
 {
 int stack_max = InventorySlots.GetStackMaxForSlotId( GetSlotID() );
 if(stack_max > 1)
 {
 m_QuantityPanel.Show( true );
 m_QuantityItem.SetText( string.Format("0/%1", stack_max.ToString()) );
 m_QuantityStack.Show( true );
 m_QuantityProgress.Show( false );
 m_PanelWidget.Show( true );
 m_ItemPreview.Show( true );
 }
 }
 
 m_ColWidget.Show( false );
 m_MountedWidget.Show( false );
 m_OutOfReachWidget.Show( false );
 m_ReservedWidget.Show( false );
 
 if( m_ItemSizePanel )
 m_ItemSizePanel.Show( false );
 
 if( m_ColorWidget )
 m_ColorWidget.Show( false );
 
 Refresh();
 }
 
 void Clear()
 {
 #ifdef PLATFORM_CONSOLE 
 m_SelectedPanel.Show(false);
 #endif
 m_CursorWidget.Show(false);
 m_EmptySelectedPanel.Show(false);
 
 ClearRemainSelected();
 }
 
 void CheckIsWeapon()
 {
 m_IsWeapon = ( Weapon_Base.Cast( m_Obj ) != null );
 }
 
 void CheckIsMagazine()
 {
 m_IsMagazine = ( Magazine.Cast( m_Obj ) != null );
 }
 
 void CheckHasTemperature()
 {
 if( m_Item )
 {
 m_HasTemperature = ( m_Item.GetTemperatureMax() != 0 && m_Item.GetTemperatureMin() != 0 );
 }
 }
 
 void CheckHasQuantity()
 {
 if( m_Item )
 {
 m_HasQuantity = ( QuantityConversions.HasItemQuantity( m_Item ) != QUANTITY_HIDDEN );
 if( m_HasQuantity )
 {
 m_QuantityPanel.Show( true );
 }
 }
 }
 
 void CheckHasItemSize()
 {
 #ifdef PLATFORM_CONSOLE
 string config = "CfgVehicles " + m_Obj.GetType() + " GUIInventoryAttachmentsProps";
 m_HasItemSize = ( InventoryItem.Cast( m_Obj ) && !GetGame().ConfigIsExisting( config ) );
 #else
 m_HasItemSize = false;
 #endif
 }
 
 bool IsOutOfReach()
 {
 bool oot = ( m_OutOfReachWidget.IsVisible() || m_MountedWidget.IsVisible() );
 return oot;
 }
 
 bool MouseEnter(Widget w, int x, int y)
 {
 if( m_Reserved )
 return MouseEnterGhostSlot(w, x, y);
 
 PrepareOwnedTooltip( m_Item, x, y );
 if( GetDragWidget() != m_PanelWidget && !IsOutOfReach() )
 {
 m_CursorWidget.Show( true );
 }
 return true;
 }
 
 bool MouseEnterGhostSlot(Widget w, int x, int y)
 {
 float pos_x, pos_y;
 m_MainWidget.GetScreenPos(pos_x, pos_y);
 
 x = pos_x;
 y = pos_y;
 
 PrepareOwnedSlotsTooltip( m_MainWidget, m_SlotDisplayName, m_SlotDesc, x, y );
 if( GetDragWidget() != m_PanelWidget )
 {
 m_EmptySelectedPanel.Show( true );
 }
 
 
 return true;
 }
 
 bool MouseLeave( Widget w, Widget s, int x, int y )
 {
 if( m_Reserved )
 return MouseLeaveGhostSlot(w, s, x, y);
 
 HideOwnedTooltip();
 if( GetDragWidget() != m_PanelWidget )
 {
 m_CursorWidget.Show( false );
 }
 return true;
 }
 
 bool MouseLeaveGhostSlot( Widget w, Widget s, int x, int y )
 {
 HideOwnedSlotsTooltip();
 
 if( GetDragWidget() != m_PanelWidget )
 {
 m_EmptySelectedPanel.Show( false );
 }
 
 return true;
 }
 
 override void UpdateInterval()
 {
 if( m_Item )
 {
 if( m_HasTemperature )
 SetTemperature();
 if( m_IsWeapon )
 RefreshMuzzleIcon();
 if( m_HasQuantity )
 SetQuantity();
 if( m_HasItemSize )
 SetItemSize();
 }
 }
 
 void OnIconDrag( Widget w )
 {
 if(!m_Obj || !w)
 {
 return;
 }
 ItemManager.GetInstance().HideDropzones();
 if( m_Obj.GetHierarchyRootPlayer() == GetGame().GetPlayer() )
 {
 ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
 }
 else
 {
 ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
 }
 
 ItemManager.GetInstance().SetIsDragging( true );
 int icon_x, icon_y;
 float icon_size, y;
 int m_sizeX, m_sizeY;
 
 if( m_Item )
 {
 GetGame().GetInventoryItemSize( m_Item, icon_x, icon_y );
 
 CargoContainer c_parent = CargoContainer.Cast( m_Parent );
 HandsPreview h_parent = HandsPreview.Cast( m_Parent );
 
 if( GetRoot().m_MainWidget.FindAnyWidget( "HandsPanel" ) )
 {
 GetRoot().m_MainWidget.FindAnyWidget( "HandsPanel" ).GetScreenSize( icon_size, y );
 }
 
 icon_size = icon_size / 10;
 
 w.SetFlags( WidgetFlags.EXACTSIZE );
 m_ItemPreview.SetForceFlipEnable(false);
 
 if( !m_Item.GetInventory().GetFlipCargo() )
 {
 w.SetSize( icon_x * icon_size , icon_y * icon_size );
 }
 else
 {
 w.SetSize( icon_y * icon_size , icon_x * icon_size );
 }
 
 m_ColWidget.Show( true );
 m_CursorWidget.Show( true );
 
 ItemManager.GetInstance().SetDraggedItem( m_Item );
 }
 m_IsDragged = true;
 }
 
 void OnIconDrop( Widget w )
 {
 m_IsDragged = false;
 ItemManager.GetInstance().HideDropzones();
 ItemManager.GetInstance().SetIsDragging( false );
 w.ClearFlags( WidgetFlags.EXACTSIZE );
 w.SetSize( 1, 1 );
 m_ColWidget.Show( false );
 m_CursorWidget.Show( false );
 m_EmptySelectedPanel.Show( false );
 m_CursorWidget.SetColor( ARGBF( 1, 1, 1, 1 ) );
 m_ItemPreview.SetForceFlipEnable(true);
 }
 
 static int GetNormalWidth()
 {
 return m_NormalWidth;
 }
 
 static int GetNormalHeight()
 {
 return m_NormalHeight;
 }
 
 /*override void HideOwnedSlotsTooltip()
 {
 if (m_TooltipOwner)
 {
 ItemManager.GetInstance().HideTooltipSlot();
 m_TooltipOwner = false;
 }
 }*/
}