4273 lines
143 KiB
C++
4273 lines
143 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
|
|
#include "cbase.h"
|
|
#include "backpack_panel.h"
|
|
#include "item_confirm_delete_dialog.h"
|
|
#include "vgui/ISurface.h"
|
|
#include "gamestringpool.h"
|
|
#include "iclientmode.h"
|
|
#include "econ_item_inventory.h"
|
|
#include "ienginevgui.h"
|
|
#include <vgui/ILocalize.h>
|
|
#include "vgui_controls/TextImage.h"
|
|
#include "vgui_controls/CheckButton.h"
|
|
#include "vgui_controls/ComboBox.h"
|
|
#include "vgui_controls/ScalableImagePanel.h"
|
|
#include "vgui/IInput.h"
|
|
#include "econ/tool_items/tool_items.h"
|
|
#include "econ_gcmessages.h"
|
|
#include "item_style_select_dialog.h"
|
|
#include "econ_item_system.h"
|
|
#include "econ_item_tools.h"
|
|
#include "econ_ui.h"
|
|
#include "gc_clientsystem.h"
|
|
#include "econ_store.h"
|
|
#include "rtime.h"
|
|
#include "econ_item_description.h"
|
|
#include "dynamic_recipe_subpanel.h"
|
|
#include "item_slot_panel.h"
|
|
#include "crate_detail_panels.h"
|
|
#include "tf_warinfopanel.h"
|
|
#include "character_info_panel.h"
|
|
#include "trading_start_dialog.h"
|
|
#include "vgui_controls/MenuItem.h"
|
|
#include "tf_duckleaderboard.h"
|
|
#include "tf_item_inventory.h"
|
|
#include "store/store_panel.h"
|
|
#include "strange_count_transfer_panel.h"
|
|
#include "collection_crafting_panel.h"
|
|
#include "halloween_offering_panel.h"
|
|
#include "store/v2/tf_store_preview_item2.h"
|
|
#include "item_ad_panel.h"
|
|
#include "client_community_market.h"
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
|
|
#ifdef STAGING_ONLY
|
|
extern ConVar tf_use_card_tooltips;
|
|
extern ConVar tf_weapon_force_allow_inspect;
|
|
#endif // STAGING_ONLY
|
|
|
|
ConVar tf_trade_up_use_count( "tf_trade_up_use_count", "3", FCVAR_ARCHIVE | FCVAR_HIDDEN );
|
|
|
|
|
|
void UseConsumableItem( CEconItemView *pItem, vgui::Panel* pParent );
|
|
|
|
const ItemSortTypeData_t g_BackpackSortTypes[] =
|
|
{
|
|
{ "#Backpack_SortBy_Header", kGCItemSort_NoSort },
|
|
{ "#Backpack_SortBy_Rarity", kGCItemSort_SortByRarity },
|
|
{ "#Backpack_SortBy_Type", kGCItemSort_SortByType },
|
|
{ "#Backpack_SortBy_Class", kTFGCItemSort_SortByClass },
|
|
{ "#Backpack_SortBy_Slot", kTFGCItemSort_SortBySlot },
|
|
{ "#Backpack_SortBy_Date", kGCItemSort_SortByDate },
|
|
};
|
|
|
|
// Array of borders for rarities. Three borders for each rarity: Base, Mouseover, and Selected
|
|
const char *g_szItemBorders[][5] =
|
|
{
|
|
{ "BackpackItemBorder", "BackpackItemMouseOverBorder", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder", "BackpackItemGreyedOutSelectedBorder" }, // AE_NORMAL = 0
|
|
{ "BackpackItemBorder_1", "BackpackItemMouseOverBorder_1", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_1", "BackpackItemGreyedOutSelectedBorder_1" }, // AE_RARITY1 = 1
|
|
{ "BackpackItemBorder_2", "BackpackItemMouseOverBorder_2", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_2", "BackpackItemGreyedOutSelectedBorder_2" }, // AE_RARITY2 = 2
|
|
{ "BackpackItemBorder_Vintage", "BackpackItemMouseOverBorder_Vintage", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_Vintage", "BackpackItemGreyedOutSelectedBorder_Vintage" }, // AE_VINTAGE = 3
|
|
{ "BackpackItemBorder_3", "BackpackItemMouseOverBorder_3", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_3", "BackpackItemGreyedOutSelectedBorder_3" }, // AE_RARITY3
|
|
{ "BackpackItemBorder_4", "BackpackItemMouseOverBorder_4", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_4", "BackpackItemGreyedOutSelectedBorder_4" }, // AE_RARITY4
|
|
{ "BackpackItemBorder_Unique", "BackpackItemMouseOverBorder_Unique", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_Unique", "BackpackItemGreyedOutSelectedBorder_Unique" }, // AE_UNIQUE
|
|
{ "BackpackItemBorder_Community", "BackpackItemMouseOverBorder_Community", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_Community", "BackpackItemGreyedOutSelectedBorder_Community" }, // AE_COMMUNITY
|
|
{ "BackpackItemBorder_Developer", "BackpackItemMouseOverBorder_Developer", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_Developer", "BackpackItemGreyedOutSelectedBorder_Developer" }, // AE_DEVELOPER
|
|
{ "BackpackItemBorder_SelfMade", "BackpackItemMouseOverBorder_SelfMade", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_SelfMade", "BackpackItemGreyedOutSelectedBorder_SelfMade" }, // AE_SELFMADE
|
|
{ "BackpackItemBorder_Customized", "BackpackItemMouseOverBorder_Customized", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_Customized", "BackpackItemGreyedOutSelectedBorder_Customized" }, // AE_CUSTOMIZED
|
|
{ "BackpackItemBorder_Strange", "BackpackItemMouseOverBorder_Strange", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_Strange", "BackpackItemGreyedOutSelectedBorder_Strange" }, // AE_STRANGE
|
|
{ "BackpackItemBorder_Completed", "BackpackItemMouseOverBorder_Completed", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_Completed", "BackpackItemGreyedOutSelectedBorder_Completed" }, // AE_COMPLETED
|
|
{ "BackpackItemBorder_Haunted", "BackpackItemMouseOverBorder_Haunted", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_Haunted", "BackpackItemGreyedOutSelectedBorder_Haunted" }, // AE_HAUNTED
|
|
{ "BackpackItemBorder_Collectors", "BackpackItemMouseOverBorder_Collectors", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_Collectors", "BackpackItemGreyedOutSelectedBorder_Collectors" }, // AE_COLLECTORS
|
|
|
|
{ "BackpackItemBorder_PaintkitWeapon", "BackpackItemMouseOverBorder_PaintkitWeapon", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_PaintkitWeapon", "BackpackItemGreyedOutSelectedBorder_PaintkitWeapon" }, // AE_Paintkit
|
|
{ "BackpackItemBorder_RarityDefault", "BackpackItemMouseOverBorder_RarityDefault", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_RarityDefault", "BackpackItemGreyedOutSelectedBorder_RarityDefault" }, // AE_RARITY_DEFAULT,
|
|
{ "BackpackItemBorder_RarityCommon", "BackpackItemMouseOverBorder_RarityCommon", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_RarityCommon", "BackpackItemGreyedOutSelectedBorder_RarityCommon" }, // AE_RARITY_COMMON,
|
|
{ "BackpackItemBorder_RarityUncommon", "BackpackItemMouseOverBorder_RarityUncommon", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_RarityUncommon", "BackpackItemGreyedOutSelectedBorder_RarityUncommon" }, // AE_RARITY_UNCOMMON,
|
|
{ "BackpackItemBorder_RarityRare", "BackpackItemMouseOverBorder_RarityRare", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_RarityRare", "BackpackItemGreyedOutSelectedBorder_RarityRare" }, // AE_RARITY_RARE,
|
|
{ "BackpackItemBorder_RarityMythical", "BackpackItemMouseOverBorder_RarityMythical", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_RarityMythical", "BackpackItemGreyedOutSelectedBorder_RarityMythical" }, // AE_RARITY_MYTHICAL,
|
|
{ "BackpackItemBorder_RarityLegendary", "BackpackItemMouseOverBorder_RarityLegendary", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_RarityLegendary", "BackpackItemGreyedOutSelectedBorder_RarityLegendary" }, // AE_RARITY_LEGENDARY,
|
|
{ "BackpackItemBorder_RarityAncient", "BackpackItemMouseOverBorder_RarityAncient", "BackpackItemSelectedBorder", "BackpackItemGreyedOutBorder_RarityAncient", "BackpackItemGreyedOutSelectedBorder_RarityAncient" }, // AE_RARITY_ANCIENT,
|
|
};
|
|
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE(g_szItemBorders) == AE_MAX_TYPES );
|
|
|
|
enum { kNoUserData = -1 };
|
|
|
|
static bool HasPaint ( const CEconItemView *pEconItemView, const char *, int )
|
|
{
|
|
static CSchemaAttributeDefHandle pAttrDef_PaintRGB( "set item tint RGB" );
|
|
static CSchemaAttributeDefHandle pAttrDef_PaintRGB2( "set item tint RGB 2" );
|
|
|
|
return pEconItemView->FindAttribute( pAttrDef_PaintRGB )
|
|
|| pEconItemView->FindAttribute( pAttrDef_PaintRGB2 );
|
|
}
|
|
|
|
static bool HasCustomAttribute ( const CEconItemView *pEconItemView, const char *szAttrName, int )
|
|
{
|
|
const CEconItemAttributeDefinition *pAttrDef = GetItemSchema()->GetAttributeDefinitionByName( szAttrName );
|
|
|
|
return pAttrDef
|
|
? pEconItemView->FindAttribute( pAttrDef )
|
|
: NULL;
|
|
}
|
|
|
|
static bool HasCustomUserAttribute ( const CEconItemView *pEconItemView, const char *, int iUserData )
|
|
{
|
|
Assert( iUserData != kNoUserData );
|
|
|
|
CCountUserGeneratedAttributeIterator countIterator;
|
|
pEconItemView->IterateAttributes( &countIterator );
|
|
|
|
return countIterator.GetCount() > iUserData;
|
|
}
|
|
|
|
static bool HasRemovableCustomName ( const CEconItemView *pEconItemView, const char *, int )
|
|
{
|
|
if ( !pEconItemView->GetItemDefinition() )
|
|
return false;
|
|
|
|
if ( pEconItemView->GetQuality() == AE_UNIQUE && pEconItemView->GetItemDefinition()->GetArmoryDescString() && !V_stricmp( pEconItemView->GetItemDefinition()->GetArmoryDescString(), "stockitem" ) )
|
|
return false;
|
|
|
|
return pEconItemView->GetSOCData() && pEconItemView->GetSOCData()->GetCustomName();
|
|
}
|
|
|
|
static bool HasRemovableCustomDesc ( const CEconItemView *pEconItemView, const char *, int )
|
|
{
|
|
if ( !pEconItemView->GetItemDefinition() )
|
|
return false;
|
|
|
|
if ( pEconItemView->GetQuality() == AE_UNIQUE && pEconItemView->GetItemDefinition()->GetArmoryDescString() && !V_stricmp( pEconItemView->GetItemDefinition()->GetArmoryDescString(), "stockitem" ) )
|
|
return false;
|
|
|
|
return pEconItemView->GetSOCData() && pEconItemView->GetSOCData()->GetCustomDesc();
|
|
}
|
|
|
|
enum EItemCustomizationRemoveType
|
|
{
|
|
kCustomizationRemove_Paint,
|
|
kCustomizationRemove_Name,
|
|
kCustomizationRemove_Desc,
|
|
kCustomizationRemove_CustomTexture,
|
|
kCustomizationRemove_MakersMark,
|
|
kCustomizationRemove_UniqueCraftIndex,
|
|
kCustomizationRemove_StrangePart,
|
|
kCustomizationRemove_StrangeScores,
|
|
kCustomizationRemove_UpgradeCard,
|
|
kCustomizationRemove_KillStreak,
|
|
kCustomizationRemove_GiftedBy,
|
|
kCustomizationRemove_Festivizer,
|
|
};
|
|
|
|
typedef bool (* HasRefurbishablePropertyFunc_t)( const CEconItemView *pEconItemView, const char *pArg, int iUserData );
|
|
|
|
void GetCustomDialogToken_PaintName( const CEconItemView *pEconItemView, int iUserData, CUtlConstWideString& out_String )
|
|
{
|
|
extern const CEconItemDefinition *GetPaintItemDefinitionForPaintedItem( const IEconItemInterface *pEconItem );
|
|
|
|
Assert( iUserData == kNoUserData );
|
|
|
|
const CEconItemDefinition *pPaintItemDef = GetPaintItemDefinitionForPaintedItem( pEconItemView );
|
|
if ( !pPaintItemDef )
|
|
{
|
|
out_String = L"";
|
|
return;
|
|
}
|
|
|
|
out_String = GLocalizationProvider()->Find( pPaintItemDef->GetItemBaseName() );
|
|
}
|
|
|
|
void GetCustomDialogToken_StrangePartName( const CEconItemView *pEconItemView, int iUserData, CUtlConstWideString& out_String )
|
|
{
|
|
extern uint32 GetScoreTypeForKillEaterAttr( const IEconItemInterface *pEconItem, const CEconItemAttributeDefinition *pAttribDef );
|
|
extern const wchar_t *GetLocalizedStringForKillEaterTypeAttr( const CLocalizationProvider *pLocalizationProvider, uint32 unKillEaterEventType ); // return type changed from locchar_t * because the backpack panel only exists on the client
|
|
|
|
uint32 unKillEaterBaseType = GetScoreTypeForKillEaterAttr( pEconItemView, GetKillEaterAttr_Type( iUserData ) );
|
|
|
|
out_String = GetLocalizedStringForKillEaterTypeAttr( GLocalizationProvider(), unKillEaterBaseType );
|
|
}
|
|
|
|
void GetCustomDialogToken_UserAttributeName( const CEconItemView *pEconItemView, int iUserData, CUtlConstWideString& out_String )
|
|
{
|
|
Assert( pEconItemView );
|
|
|
|
const CEconItemAttributeDefinition *pAttrDef = GetCardUpgradeForIndex( pEconItemView, iUserData );
|
|
if ( !pAttrDef )
|
|
{
|
|
out_String = L"unknown";
|
|
return;
|
|
}
|
|
|
|
attrib_value_t attrVal;
|
|
Verify( pEconItemView->FindAttribute( pAttrDef, &attrVal ) );
|
|
CEconAttributeDescription attrDesc( GLocalizationProvider(), pAttrDef, attrVal );
|
|
out_String = attrDesc.GetShortDescription();
|
|
}
|
|
|
|
typedef void (* GetCustomDialogLocalizationTokenFunc_t)( const CEconItemView *pEconItemView, int iUserData, CUtlConstWideString& out_String );
|
|
|
|
struct RefurbishableProperty
|
|
{
|
|
HasRefurbishablePropertyFunc_t m_pFunc;
|
|
GetCustomDialogLocalizationTokenFunc_t m_pGetCustomDialogLocalizationTokenFunc;
|
|
const char *m_szArg;
|
|
const char *m_pszSelectionUILocalizationToken;
|
|
const char *m_szDialogTitle;
|
|
const char *m_szDialogDesc;
|
|
EItemCustomizationRemoveType m_eRemovalType;
|
|
int m_iUserData;
|
|
};
|
|
|
|
// TODO: Add Gifted by Tag here
|
|
static RefurbishableProperty g_RemoveableAttributes[] =
|
|
{
|
|
{ &HasRemovableCustomName, NULL, NULL, "#RefurbishItem_RemoveNameCombo", "#RefurbishItem_RemoveNameTitle", "#RefurbishItem_RemoveName", kCustomizationRemove_Name, kNoUserData }, // does this item have a custom name?
|
|
{ &HasRemovableCustomDesc, NULL, NULL, "#RefurbishItem_RemoveDescCombo", "#RefurbishItem_RemoveDescTitle", "#RefurbishItem_RemoveDesc", kCustomizationRemove_Desc, kNoUserData }, // does this item have a custom description?
|
|
{ &HasPaint, &GetCustomDialogToken_PaintName, "set item tint rgb", "#RefurbishItem_RemovePaintCombo", "#RefurbishItem_RemovePaintTitle", "#RefurbishItem_RemovePaint", kCustomizationRemove_Paint, kNoUserData }, // is this item painted?
|
|
{ &HasCustomAttribute, NULL, "custom texture hi", "#RefurbishItem_RemoveCustomTextureCombo", "#RefurbishItem_RemoveCustomTextureTitle", "#RefurbishItem_RemoveCustomTexture", kCustomizationRemove_CustomTexture, kNoUserData }, // does this have a custom texture applied?
|
|
{ &HasCustomAttribute, NULL, "makers mark id", "#RefurbishItem_RemoveMakersMarkCombo", "#RefurbishItem_RemoveMakersMarkTitle", "#RefurbishItem_RemoveMakersMark", kCustomizationRemove_MakersMark, kNoUserData }, // was this item crafted by a specific dude?
|
|
{ &HasCustomAttribute, NULL, "killstreak tier", "#RefurbishItem_RemoveKillStreakCombo", "#RefurbishItem_RemoveKillStreakTitle", "#RefurbishItem_RemoveKillStreak", kCustomizationRemove_KillStreak, kNoUserData }, // Killstreak Effect
|
|
{ &HasCustomAttribute, NULL, "gifter account id", "#RefurbishItem_RemoveGifterCombo", "#RefurbishItem_RemoveGifterTitle", "#RefurbishItem_RemoveGifter", kCustomizationRemove_GiftedBy, kNoUserData }, // Gifted by
|
|
{ &HasCustomAttribute, NULL, "is_festivized", "#RefurbishItem_RemoveFestivizerCombo", "#RefurbishItem_RemoveFestivizerTitle", "#RefurbishItem_RemoveFestivizer", kCustomizationRemove_Festivizer, kNoUserData }, // Festivizer
|
|
|
|
//"gifter account id", // who gifted us this item? (will also remove "event date")
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Look over this weapon to see if it has any strange stat counters to reset optionally.
|
|
//-----------------------------------------------------------------------------
|
|
static bool HasResettableScoreAttributes ( const CEconItemView *pEconItemView, const char *, int )
|
|
{
|
|
if ( !pEconItemView )
|
|
return false;
|
|
|
|
for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
|
|
{
|
|
uint32 unScore;
|
|
if ( pEconItemView->FindAttribute( GetKillEaterAttr_Score( i ), &unScore ) && unScore > 0 )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int GetRemovableAttributesCount()
|
|
{
|
|
return ARRAYSIZE( g_RemoveableAttributes )
|
|
+ GetKillEaterAttrCount()
|
|
+ GetMaxCardUpgradesPerItem() // remove card upgrades
|
|
+ 1; // strange quality item score reset
|
|
}
|
|
|
|
RefurbishableProperty RemovableAttributes_GetAttributeDetails( int i )
|
|
{
|
|
Assert( i >= 0 );
|
|
Assert( i < GetRemovableAttributesCount() );
|
|
|
|
if ( i < ARRAYSIZE( g_RemoveableAttributes ) )
|
|
return g_RemoveableAttributes[i];
|
|
|
|
// Which attribute in particular are we looking for?
|
|
int iStrangePartIndex = i - ARRAYSIZE( g_RemoveableAttributes );
|
|
if ( iStrangePartIndex < GetKillEaterAttrCount() )
|
|
{
|
|
int iKillEaterAttrIndex = (GetKillEaterAttrCount() - GetKillEaterAttrCount()) + iStrangePartIndex;
|
|
|
|
// if we're looking at strange attributes...
|
|
if ( GetKillEaterAttr_IsUserCustomizable( iKillEaterAttrIndex ) )
|
|
{
|
|
// Common properties for all strange part attributes.
|
|
static RefurbishableProperty sStrangePartProperty = { &HasCustomAttribute, &GetCustomDialogToken_StrangePartName, NULL, "#RefurbishItem_RemoveStrangePartCombo", "#RefurbishItem_RemoveStrangePartTitle", "#RefurbishItem_RemoveStrangePart", kCustomizationRemove_StrangePart, kNoUserData };
|
|
|
|
RefurbishableProperty partReturnProp = sStrangePartProperty;
|
|
partReturnProp.m_szArg = GetKillEaterAttr_Score( iKillEaterAttrIndex )->GetDefinitionName(); // ...then we check for the presence of a score attribute if this slot is a strange part...
|
|
partReturnProp.m_iUserData = iKillEaterAttrIndex;
|
|
|
|
return partReturnProp;
|
|
}
|
|
|
|
// ...or the presence of a restriction attribute if this slot is a base slot that might have a filter
|
|
static RefurbishableProperty sStrangeFilterProperty = { &HasCustomAttribute, &GetCustomDialogToken_StrangePartName, NULL, "#RefurbishItem_RemoveStrangeFilterCombo", "#RefurbishItem_RemoveStrangeFilterTitle", "#RefurbishItem_RemoveStrangeFilter", kCustomizationRemove_StrangePart, kNoUserData };
|
|
|
|
RefurbishableProperty filterReturnProp = sStrangeFilterProperty;
|
|
filterReturnProp.m_szArg = GetKillEaterAttr_Restriction( iKillEaterAttrIndex )->GetDefinitionName();
|
|
filterReturnProp.m_iUserData = iKillEaterAttrIndex;
|
|
|
|
return filterReturnProp;
|
|
}
|
|
|
|
// Look for any properties that were user-assigned. We allow users to remove them.
|
|
int iCardUpgradeIndex = iStrangePartIndex - GetKillEaterAttrCount();
|
|
if ( iCardUpgradeIndex < GetMaxCardUpgradesPerItem() )
|
|
{
|
|
// Common properties for all card upgrade attributes.
|
|
static RefurbishableProperty sCardUpgradeProperty = { &HasCustomUserAttribute, &GetCustomDialogToken_UserAttributeName, NULL, "#RefurbishItem_RemoveSpellCombo", "#RefurbishItem_RemoveSpellTitle", "#RefurbishItem_RemoveSpellUpgrade", kCustomizationRemove_UpgradeCard, kNoUserData };
|
|
|
|
RefurbishableProperty returnProp = sCardUpgradeProperty;
|
|
// FIX THIS FOR CARDS / SPELLS?
|
|
// returnProp.m_szArg = GetCustomDialogToken_UserAttributeName ?
|
|
returnProp.m_iUserData = iCardUpgradeIndex;
|
|
|
|
return returnProp;
|
|
}
|
|
|
|
// We might also be trying to reset the strange score counters.
|
|
Assert( iStrangePartIndex == GetKillEaterAttrCount() + GetMaxCardUpgradesPerItem() );
|
|
Assert( i == GetRemovableAttributesCount() - 1 );
|
|
|
|
static RefurbishableProperty sStrangeScoreReset = { &HasResettableScoreAttributes, NULL, NULL, "#RefurbishItem_RemoveStrangeScoresCombo", "#RefurbishItem_RemoveStrangeScoresTitle", "#RefurbishItem_RemoveStrangeScores", kCustomizationRemove_StrangeScores, kNoUserData };
|
|
return sStrangeScoreReset;
|
|
}
|
|
|
|
bool RemovableAttributes_DoesAttributeApply( int i, const CEconItemView *pEconItemView )
|
|
{
|
|
static CSchemaAttributeDefHandle pAttr_CannotRestore( "cannot restore" );
|
|
if ( pEconItemView->FindAttribute( pAttr_CannotRestore ) )
|
|
return false;
|
|
|
|
RefurbishableProperty attr = RemovableAttributes_GetAttributeDetails( i );
|
|
|
|
return attr.m_pFunc( pEconItemView, attr.m_szArg, attr.m_iUserData );
|
|
}
|
|
|
|
bool RemovableAttributes_DoAnyAttributesApply( const CEconItemView *pEconItemView )
|
|
{
|
|
static CSchemaAttributeDefHandle pAttr_CannotRestore( "cannot restore" );
|
|
if ( pEconItemView->FindAttribute( pAttr_CannotRestore ) )
|
|
return false;
|
|
|
|
for ( int i = 0; i < GetRemovableAttributesCount(); i++ )
|
|
{
|
|
if ( RemovableAttributes_DoesAttributeApply( i, pEconItemView ) )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
ConVar cl_showbackpackrarities( "cl_showbackpackrarities", "0", FCVAR_ARCHIVE, "0 = Show no backpack icon border colors. 1 = Show item rarities within the backpack. 2 = Show item rarities only for Market-listable items." );
|
|
ConVar cl_show_market_data_on_items( "cl_show_market_data_on_items", "1", FCVAR_ARCHIVE, "0 = Never. 1 = Only when showing borders for Market-listable items. 2 = Always." );
|
|
|
|
ConVar tf_explanations_backpackpanel( "tf_explanations_backpackpanel", "0", FCVAR_ARCHIVE, "Whether the user has seen explanations for this panel." );
|
|
|
|
ConVar tf_backpack_page_button_delay( "tf_backpack_page_button_delay", "0.5", FCVAR_ARCHIVE, "Amount of time the mouse cursor needs to hover over the page button to select the page." );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CBackpackPanel::CBackpackPanel( vgui::Panel *parent, const char *panelName ) : CBaseLoadoutPanel( parent, panelName )
|
|
{
|
|
m_nQuickOpenTxn = 0;
|
|
m_pContextMenu = NULL;
|
|
m_pPageButtonKVs = NULL;
|
|
m_mapSeenItems.SetLessFunc( DefLessFunc( itemid_t ) );
|
|
m_bInitializedSeenItems = false;
|
|
m_pNameFilterTextEntry = NULL;
|
|
m_flFilterItemTime = 0.f;
|
|
m_mapFilteringItems.SetLessFunc( DefLessFunc(int) );
|
|
|
|
m_pNextPageButton = NULL;
|
|
m_pPrevPageButton = NULL;
|
|
m_pShowExplanationsButton = NULL;
|
|
m_pCurPageLabel = NULL;
|
|
m_pSortByComboBox = NULL;
|
|
m_pShowRarityComboBox = NULL;
|
|
m_pShowBaseItemsCheckbox = NULL;
|
|
m_pDragToNextPageButton = NULL;
|
|
m_pDragToPrevPageButton = NULL;
|
|
m_flPreventDragPageSwitchUntil = 0;
|
|
m_flStartExplanationsAt = 0;
|
|
|
|
m_flMouseDownTime = 0;
|
|
m_pItemDraggedFromPanel = NULL;
|
|
m_iDraggedFromPage = 0;
|
|
m_bMouseDownOnItemPanel = false;
|
|
m_bDragging = false;
|
|
m_iMouseDownX = m_iMouseDownY = 0;
|
|
|
|
m_pMouseDragItemPanel = vgui::SETUP_PANEL( new CItemModelPanel( this, "mousedragitempanel" ) );
|
|
m_pCancelToolButton = NULL;
|
|
m_pCraftButton = NULL;
|
|
m_bShowBaseItems = false;
|
|
m_pConfirmDeleteDialog = NULL;
|
|
m_pToolIcon = NULL;
|
|
m_eSelectionMode = StandardSelection;
|
|
m_nLastToolPage = 0;
|
|
m_pDynamicRecipePanel = NULL;
|
|
m_pItemSlotPanel = NULL;
|
|
m_pStrangeToolPanel = NULL;
|
|
|
|
m_nNumActivePages = 0;
|
|
|
|
m_pInspectPanel = new CTFItemInspectionPanel( this, "InspectionPanel" );
|
|
m_pInspectCosmeticPanel = new CTFStorePreviewItemPanel2( this, "Resource/UI/econ/InspectionPanel_Cosmetic.res", "storepreviewitem", NULL );
|
|
m_pCollectionCraftPanel = NULL;
|
|
m_pHalloweenOfferingPanel = NULL;
|
|
m_pMannCoTradePanel = NULL;
|
|
|
|
CancelToolSelection();
|
|
|
|
ListenForGameEvent( "gc_connected" );
|
|
}
|
|
|
|
CBackpackPanel::~CBackpackPanel()
|
|
{
|
|
if ( m_pPageButtonKVs )
|
|
{
|
|
m_pPageButtonKVs->deleteThis();
|
|
m_pPageButtonKVs = NULL;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
|
|
{
|
|
if ( !m_pSortByComboBox && UsesRarityControls() )
|
|
{
|
|
m_pSortByComboBox = new vgui::ComboBox( this, "SortByComboBox", 5, false );
|
|
m_pSortByComboBox->AddActionSignalTarget( this );
|
|
}
|
|
|
|
LoadControlSettings( GetResFile() );
|
|
|
|
BaseClass::ApplySchemeSettings( pScheme );
|
|
|
|
m_pNameFilterTextEntry = FindControl<vgui::TextEntry>( "NameFilterTextEntry" );
|
|
if ( m_pNameFilterTextEntry )
|
|
{
|
|
m_pNameFilterTextEntry->AddActionSignalTarget( this );
|
|
}
|
|
|
|
m_pCancelToolButton = dynamic_cast<CExButton*>( FindChildByName("CancelApplyToolButton") );
|
|
m_pCraftButton = dynamic_cast<CExButton*>( FindChildByName("CraftButton") );
|
|
m_pToolIcon = dynamic_cast<vgui::ScalableImagePanel*>( FindChildByName("tool_icon") );
|
|
|
|
m_pNextPageButton = dynamic_cast<CExButton*>( FindChildByName("NextPageButton") );
|
|
m_pPrevPageButton = dynamic_cast<CExButton*>( FindChildByName("PrevPageButton") );
|
|
m_pShowExplanationsButton = dynamic_cast<CExButton*>( FindChildByName("ShowExplanationsButton") );
|
|
m_pDragToNextPageButton = dynamic_cast<CExButton*>( FindChildByName("DragToNextPageButton") );
|
|
m_pDragToPrevPageButton = dynamic_cast<CExButton*>( FindChildByName("DragToPrevPageButton") );
|
|
m_pCurPageLabel = dynamic_cast<vgui::Label*>( FindChildByName("CurPageLabel") );
|
|
m_pShowRarityComboBox = dynamic_cast<vgui::ComboBox*>( FindChildByName( "ShowRarityComboBox" ) );
|
|
if ( m_pShowRarityComboBox )
|
|
{
|
|
m_pShowRarityComboBox->AddActionSignalTarget( this );
|
|
|
|
m_pShowRarityComboBox->AddItem( "#TF_Backpack_ShowNoBorders", NULL );
|
|
m_pShowRarityComboBox->AddItem( "#TF_Backpack_ShowQualityBorders", NULL );
|
|
m_pShowRarityComboBox->AddItem( "#TF_Backpack_ShowMarketableBorders", NULL );
|
|
|
|
m_pShowRarityComboBox->ActivateItemByRow( cl_showbackpackrarities.GetInt() );
|
|
}
|
|
m_pShowBaseItemsCheckbox = dynamic_cast<vgui::CheckButton*>( FindChildByName( "ShowBaseItemsCheckbox" ) );
|
|
if ( m_pShowBaseItemsCheckbox )
|
|
{
|
|
m_pShowBaseItemsCheckbox->AddActionSignalTarget( this );
|
|
m_pShowBaseItemsCheckbox->SetSelected( m_bShowBaseItems );
|
|
}
|
|
|
|
m_pMouseDragItemPanel->SetBorder( pScheme->GetBorder("BackpackItemMouseOverBorder") );
|
|
|
|
// Setup our combo box
|
|
if ( m_pSortByComboBox )
|
|
{
|
|
m_pSortByComboBox->RemoveAll();
|
|
vgui::HFont hFont = pScheme->GetFont( "HudFontSmallestBold", true );
|
|
m_pSortByComboBox->SetFont( hFont );
|
|
KeyValues *pKeyValues = new KeyValues( "data" );
|
|
for ( int i = 0; i < ARRAYSIZE(g_BackpackSortTypes); i++ )
|
|
{
|
|
pKeyValues->SetInt( "sortby", i );
|
|
m_pSortByComboBox->AddItem( g_BackpackSortTypes[i].szSortDesc, pKeyValues );
|
|
}
|
|
pKeyValues->deleteThis();
|
|
m_pSortByComboBox->ActivateItemByRow( 0 );
|
|
m_pSortByComboBox->GetMenu()->SetNumberOfVisibleItems( ARRAYSIZE(g_BackpackSortTypes) );
|
|
}
|
|
|
|
// Create page buttons
|
|
const int nNumMaxPages = GetNumMaxPages();
|
|
for ( int i=m_Pages.Count(); i<nNumMaxPages; ++i )
|
|
{
|
|
EditablePanel *pPage = vgui::SETUP_PANEL( new EditablePanel( this, CFmtStr( "page_%d", i ) ) );
|
|
m_Pages.AddToTail( pPage );
|
|
}
|
|
|
|
if ( m_pInspectCosmeticPanel )
|
|
{
|
|
// Force it to load it's scheme now, because it needs to be done before we set it's visibility below
|
|
m_pInspectCosmeticPanel->InvalidateLayout( false, true );
|
|
m_pInspectCosmeticPanel->SetVisible( false );
|
|
}
|
|
}
|
|
|
|
void CBackpackPanel::ApplySettings( KeyValues *inResourceData )
|
|
{
|
|
BaseClass::ApplySettings( inResourceData );
|
|
|
|
KeyValues *pItemKV = inResourceData->FindKey( "pagebuttons_kv" );
|
|
if ( pItemKV )
|
|
{
|
|
if ( m_pPageButtonKVs )
|
|
{
|
|
m_pPageButtonKVs->deleteThis();
|
|
}
|
|
m_pPageButtonKVs = new KeyValues("pagebuttons_kv");
|
|
pItemKV->CopySubkeys( m_pPageButtonKVs );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::AddNewItemPanel( int iPanelIndex )
|
|
{
|
|
BaseClass::AddNewItemPanel( iPanelIndex );
|
|
|
|
// Store a position for our new panel
|
|
m_ItemModelPanelPos.AddToTail();
|
|
m_ItemModelPanelPos[iPanelIndex].x = m_ItemModelPanelPos[iPanelIndex].y = 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CItemModelPanel *CBackpackPanel::GetItemPanelAtPos( int x, int y )
|
|
{
|
|
if ( !m_pItemModelPanels.Count() )
|
|
return NULL;
|
|
|
|
int iW = m_pItemModelPanels[0]->GetWide();
|
|
int iH = m_pItemModelPanels[0]->GetTall();
|
|
for ( int i = 0; i < m_ItemModelPanelPos.Count(); i++ )
|
|
{
|
|
if ( (x < m_ItemModelPanelPos[i].x) || (x > (m_ItemModelPanelPos[i].x + iW)) )
|
|
continue;
|
|
if ( (y < m_ItemModelPanelPos[i].y) || (y > (m_ItemModelPanelPos[i].y + iH)) )
|
|
continue;
|
|
return m_pItemModelPanels[i];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CBackpackPanel::GetPageButtonIndexAtPos( int x, int y )
|
|
{
|
|
if ( !m_Pages.Count() )
|
|
return -1;
|
|
|
|
int iW = m_Pages[0]->GetWide();
|
|
int iH = m_Pages[0]->GetTall();
|
|
for ( int i = 0; i < m_PageButtonPos.Count(); i++ )
|
|
{
|
|
if ( (x < m_PageButtonPos[i].x) || (x > (m_PageButtonPos[i].x + iW)) )
|
|
continue;
|
|
if ( (y < m_PageButtonPos[i].y) || (y > (m_PageButtonPos[i].y + iH)) )
|
|
continue;
|
|
return m_Pages[i]->IsVisible() ? i : -1;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Change the text color on the page buttons based on the context of the
|
|
// page they represent.
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::SetPageButtonTextColorBasedOnContents()
|
|
{
|
|
vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );
|
|
|
|
if ( m_Pages.Count() == 0 )
|
|
return;
|
|
|
|
if ( !pScheme )
|
|
return;
|
|
|
|
const Color& colorEmpty = pScheme->GetColor( "TanDarker", Color( 235, 226, 202, 255 ) );
|
|
const Color& colorPartial = Color( 170, 161, 137, 255 );
|
|
const Color& colorFull = pScheme->GetColor( "TanLight", Color( 235, 226, 202, 255 ) );
|
|
const Color& colorSelected = pScheme->GetColor( "TFOrange", Color( 145, 73, 59, 255 ) );
|
|
|
|
CUtlVector<int> vecPageCount;
|
|
CUtlVector<int> vecNewPageCount;
|
|
vecPageCount.EnsureCount( m_Pages.Count() );
|
|
vecNewPageCount.EnsureCount( m_Pages.Count() );
|
|
// Initialize to 0
|
|
FOR_EACH_VEC( vecPageCount, i )
|
|
{
|
|
vecPageCount[i] = 0;
|
|
vecNewPageCount[i] = 0;
|
|
}
|
|
|
|
CPlayerInventory *pInv = InventoryManager()->GetLocalInventory();
|
|
Assert( pInv );
|
|
// Tally up how many items are on each page
|
|
if ( pInv )
|
|
{
|
|
for ( int i = 0 ; i < pInv->GetItemCount() ; ++i )
|
|
{
|
|
CEconItemView *pItem = pInv->GetItem( i );
|
|
const int nSlot = InventoryManager()->GetBackpackPositionFromBackend( pItem->GetInventoryPosition() ) - 1;
|
|
const int nPage = nSlot / GetNumSlotsPerPage();
|
|
if ( nPage >= 0 && nPage < m_Pages.Count() )
|
|
{
|
|
vecPageCount[ nPage ] = vecPageCount[ nPage ] + 1;
|
|
|
|
// Unackknowledged items technically are on the 1st page, so dont count them
|
|
if ( m_mapSeenItems.Find( pItem->GetItemID() ) == m_mapSeenItems.InvalidIndex()
|
|
&& IsUnacknowledged( pItem->GetInventoryPosition() ) == false && !m_bShowBaseItems && !HasNameFilter() )
|
|
{
|
|
vecNewPageCount[ nPage ] = vecNewPageCount[ nPage ] + 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set the color for each page button
|
|
FOR_EACH_VEC( m_Pages, i )
|
|
{
|
|
const int nNewCount = vecNewPageCount[i];
|
|
const int nCount = vecPageCount[i];
|
|
CExButton* pButton = dynamic_cast<CExButton*>( m_Pages[i]->FindChildByName( "Button" ) );
|
|
if ( pButton )
|
|
{
|
|
Color setColor = colorEmpty;
|
|
const Color& bgColor = GetCurrentPage() == i ? colorSelected : pButton->GetButtonDefaultBgColor();
|
|
|
|
if ( nCount == GetNumSlotsPerPage() )
|
|
setColor = colorFull;
|
|
else if ( nCount > 0 )
|
|
setColor = colorPartial;
|
|
|
|
pButton->SetSelectedColor( setColor, pButton->GetButtonSelectedBgColor() );
|
|
pButton->SetDefaultColor( setColor, bgColor );
|
|
pButton->SetArmedColor( setColor, pButton->GetButtonArmedBgColor() );
|
|
pButton->SetDepressedColor( setColor, pButton->GetButtonDepressedBgColor() );
|
|
}
|
|
|
|
// Show our "NEW!" label if there's any unseen items on that page
|
|
CExLabel* pNew = dynamic_cast<CExLabel*>( m_Pages[i]->FindChildByName( "New" ) );
|
|
if ( pNew )
|
|
{
|
|
pNew->SetVisible( nNewCount > 0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::MarkItemIDDirty( itemid_t itemID )
|
|
{
|
|
if ( m_vecDirtyItems.Find( itemID ) == m_vecDirtyItems.InvalidIndex() )
|
|
{
|
|
m_vecDirtyItems.AddToTail( itemID );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::PositionItemPanel( CItemModelPanel *pPanel, int iIndex )
|
|
{
|
|
int iCenter = GetWide() * 0.5;
|
|
int iButtonX = (iIndex % GetNumColumns());
|
|
int iButtonY = (iIndex / GetNumColumns());
|
|
int iXPos = (iCenter + m_iItemBackpackOffcenterX) + (iButtonX * m_pItemModelPanels[iIndex]->GetWide()) + (m_iItemBackpackXDelta * iButtonX);
|
|
int iYPos = m_iItemYPos + (iButtonY * m_pItemModelPanels[iIndex]->GetTall() ) + (m_iItemBackpackYDelta * iButtonY);
|
|
|
|
m_pItemModelPanels[iIndex]->SetPos( iXPos, iYPos );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::PerformLayout( void )
|
|
{
|
|
BaseClass::PerformLayout();
|
|
|
|
for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
|
|
{
|
|
// Viewing the backpack. Layout all the buttons and hide the class image.
|
|
m_pItemModelPanels[i]->SetVisible( true );
|
|
m_pItemModelPanels[i]->SetNoItemText( "#SelectNoItemSlot" );
|
|
|
|
PositionItemPanel( m_pItemModelPanels[i], i );
|
|
|
|
// Cache off where we put the panel
|
|
m_pItemModelPanels[i]->GetPos( m_ItemModelPanelPos[i].x, m_ItemModelPanelPos[i].y );
|
|
|
|
// Take into account parent's position
|
|
Panel* pParent = m_pItemModelPanels[i]->GetParent();
|
|
if( pParent )
|
|
{
|
|
int x = 0,y = 0;
|
|
pParent->GetPos( x, y );
|
|
m_ItemModelPanelPos[i].x += x;
|
|
m_ItemModelPanelPos[i].y += y;
|
|
}
|
|
}
|
|
|
|
// adjust page buttons
|
|
{
|
|
m_nNumActivePages = GetNumPages();
|
|
|
|
int iCenter = GetWide() * 0.5;
|
|
|
|
int iPageBarWidth = 2 * abs( m_iItemBackpackOffcenterX );
|
|
int iPageButtonWidth = ( iPageBarWidth - ( m_iPageButtonPerRow - 1 ) * m_iPageButtonXDelta ) / m_iPageButtonPerRow;
|
|
int iPageButtonWidthPlusDelta = iPageButtonWidth + m_iPageButtonXDelta;
|
|
int iPageButtonHeightPlusDelta = m_iPageButtonHeight + m_iPageButtonYDelta;
|
|
int iStart = iCenter + m_iItemBackpackOffcenterX;
|
|
|
|
m_PageButtonPos.EnsureCount( m_Pages.Count() );
|
|
for ( int i=0; i<m_Pages.Count(); ++i )
|
|
{
|
|
EditablePanel *pPage = m_Pages[i];
|
|
if ( pPage )
|
|
{
|
|
// Apply control settings here
|
|
if ( m_pPageButtonKVs )
|
|
pPage->ApplySettings( m_pPageButtonKVs );
|
|
CExButton* pButton = dynamic_cast<CExButton*>( pPage->FindChildByName( "Button" ) );
|
|
pPage->InvalidateLayout( true, true );
|
|
// Make the button have the right command and send it's signals to us
|
|
if ( pButton )
|
|
{
|
|
pButton->SetSelected( false );
|
|
pButton->SetCommand( CFmtStr( "goto_page_%d", i ) );
|
|
pButton->AddActionSignalTarget( this );
|
|
}
|
|
pPage->SetDialogVariable( "page", i+1 );
|
|
|
|
bool bVisible = i < m_nNumActivePages;
|
|
if ( bVisible )
|
|
{
|
|
int iRow = i /m_iPageButtonPerRow;
|
|
int iColumn = i % m_iPageButtonPerRow;
|
|
pPage->SetBounds( iStart + iColumn * iPageButtonWidthPlusDelta, m_iPageButtonYPos + iRow * iPageButtonHeightPlusDelta, iPageButtonWidth, m_iPageButtonHeight );
|
|
pPage->GetPos( m_PageButtonPos[i].x , m_PageButtonPos[i].y );
|
|
}
|
|
pPage->SetVisible( bVisible );
|
|
}
|
|
}
|
|
|
|
// Update colors and the "NEW!" labels
|
|
SetPageButtonTextColorBasedOnContents();
|
|
}
|
|
|
|
if ( m_pNextPageButton )
|
|
{
|
|
m_pNextPageButton->SetVisible( true );
|
|
}
|
|
if ( m_pPrevPageButton )
|
|
{
|
|
m_pPrevPageButton->SetVisible( true );
|
|
}
|
|
if ( m_pCurPageLabel )
|
|
{
|
|
m_pCurPageLabel->SetVisible( true );
|
|
}
|
|
|
|
if ( m_pSortByComboBox )
|
|
{
|
|
m_pSortByComboBox->SetVisible( !InToolSelectionMode() );
|
|
}
|
|
if ( m_pShowRarityComboBox )
|
|
{
|
|
m_pShowRarityComboBox->SetVisible( true );
|
|
}
|
|
|
|
if ( m_pNextPageButton )
|
|
{
|
|
m_pNextPageButton->SetEnabled( GetNumPages() > 1 );
|
|
}
|
|
if ( m_pPrevPageButton )
|
|
{
|
|
m_pPrevPageButton->SetEnabled( GetNumPages() > 1 );
|
|
}
|
|
|
|
if ( !m_bDragging )
|
|
{
|
|
if ( m_pDragToNextPageButton && m_pDragToPrevPageButton )
|
|
{
|
|
m_pDragToNextPageButton->SetVisible( false );
|
|
m_pDragToPrevPageButton->SetVisible( false );
|
|
}
|
|
}
|
|
|
|
bool bShowActions = (!m_bItemsOnly && !InToolSelectionMode());
|
|
if ( m_pCraftButton )
|
|
{
|
|
m_pCraftButton->SetVisible( bShowActions );
|
|
}
|
|
if ( m_pCancelToolButton )
|
|
{
|
|
m_pCancelToolButton->SetVisible( InToolSelectionMode() );
|
|
}
|
|
|
|
if ( m_pShowExplanationsButton )
|
|
{
|
|
m_pShowExplanationsButton->SetVisible( !m_bItemsOnly );
|
|
}
|
|
if ( m_pShowBaseItemsCheckbox )
|
|
{
|
|
m_pShowBaseItemsCheckbox->SetVisible( !m_bItemsOnly );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::FireGameEvent( IGameEvent *event )
|
|
{
|
|
static CSchemaItemDefHandle pItemDef_BasePaintCan( "Paint Can" );
|
|
const char *type = event->GetName();
|
|
if ( Q_strcmp( "gc_connected", type ) == 0 )
|
|
{
|
|
if ( !m_bInitializedSeenItems )
|
|
{
|
|
CPlayerInventory *pInventory = InventoryManager()->GetLocalInventory();
|
|
if ( pInventory )
|
|
{
|
|
for ( int i = 0; i < pInventory->GetItemCount(); i++ )
|
|
{
|
|
CEconItemView *pItem = pInventory->GetItem(i);
|
|
m_mapSeenItems.Insert( pItem->GetItemID() );
|
|
}
|
|
}
|
|
|
|
m_bInitializedSeenItems = true;
|
|
}
|
|
|
|
m_vecPaintCans.Purge();
|
|
m_vecStrangeParts.Purge();
|
|
const CEconItemSchema::ToolsItemDefinitionMap_t &toolDefs = GetItemSchema()->GetToolsItemDefinitionMap();
|
|
|
|
// Store all of the active paint can item defs
|
|
FOR_EACH_MAP_FAST( toolDefs, i )
|
|
{
|
|
const CEconItemDefinition *pItemDef = toolDefs[i];
|
|
const IEconTool *pEconTool = pItemDef->GetEconTool();
|
|
if ( !pEconTool )
|
|
continue;
|
|
|
|
// Paint can list
|
|
// Ignore the stock paintcan thats only for armory purposes
|
|
if ( !V_strcmp( pEconTool->GetTypeName(), "paint_can" ) && pItemDef_BasePaintCan != pItemDef )
|
|
{
|
|
// Paint Can
|
|
m_vecPaintCans.AddToTail( pItemDef->GetDefinitionIndex() );
|
|
}
|
|
// Strange Parts List
|
|
else if ( !V_strcmp( pEconTool->GetTypeName(), "strange_part" ) )
|
|
{
|
|
m_vecStrangeParts.AddToTail( pItemDef->GetDefinitionIndex() );
|
|
}
|
|
}
|
|
}
|
|
|
|
BaseClass::FireGameEvent( event );
|
|
}
|
|
|
|
void CBackpackPanel::CheckForQuickOpenKey()
|
|
{
|
|
if ( !m_hQuickOpenCrate )
|
|
return;
|
|
|
|
// We only want to continue if it's the transaction we're listening for
|
|
if ( EconUI()->GetStorePanel()->GetMostRecentSuccessfulTransactionID() != m_nQuickOpenTxn )
|
|
{
|
|
return;
|
|
}
|
|
|
|
CPlayerInventory *pInventory = InventoryManager()->GetLocalInventory();
|
|
if ( pInventory )
|
|
{
|
|
for ( int i = 0; i < pInventory->GetItemCount(); i++ )
|
|
{
|
|
CEconItemView *pInvItem = pInventory->GetItem( i );
|
|
|
|
uint32 iPosition = pInvItem->GetInventoryPosition();
|
|
if ( IsUnacknowledged( iPosition ) == false )
|
|
continue;
|
|
|
|
if ( InventoryManager()->GetBackpackPositionFromBackend( iPosition ) != 0 )
|
|
continue;
|
|
|
|
// Now make sure we haven't got a clientside saved ack for this item.
|
|
if ( InventoryManager()->HasBeenAckedByClient( pInvItem ) )
|
|
continue;
|
|
|
|
// If item is not a drop we want to show the notification otherwise they'll get the notification on death
|
|
int iFoundMethod = GetUnacknowledgedReason( iPosition );
|
|
if ( iFoundMethod != UNACK_ITEM_PURCHASED )
|
|
continue;
|
|
|
|
if ( !pInvItem->GetStaticData()->IsTool() )
|
|
continue;
|
|
|
|
if( !CEconSharedToolSupport::ToolCanApplyTo( pInvItem, m_hQuickOpenCrate ) )
|
|
continue;
|
|
|
|
if ( !pInvItem->GetStaticData()->GetEconTool() )
|
|
continue;
|
|
|
|
if ( !Q_strcmp( pInvItem->GetStaticData()->GetEconTool()->GetTypeName(), "decoder_ring" ) == 0 )
|
|
continue;
|
|
|
|
ApplyTool( this, pInvItem, m_hQuickOpenCrate );
|
|
CloseStoreStatusDialog();
|
|
|
|
m_hQuickOpenCrate = NULL;
|
|
m_nQuickOpenTxn = 0;
|
|
return;
|
|
}
|
|
}
|
|
|
|
m_hQuickOpenCrate = NULL;
|
|
m_nQuickOpenTxn = 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: When the store get's a new transaction ID, it comes here as well
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::SetCurrentTransactionID( uint64 nTxnID )
|
|
{
|
|
// If we've got a quick open crate st, and no quick open transaction ID,
|
|
// then we want to capture the incoming transaction ID so that we can
|
|
// compare future incoming successful transactions to see if they have
|
|
// the key we're expecting
|
|
if ( m_hQuickOpenCrate && m_nQuickOpenTxn == 0 )
|
|
{
|
|
m_nQuickOpenTxn = nTxnID;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnShowPanel( bool bVisible, bool bReturningFromArmory )
|
|
{
|
|
if ( bVisible )
|
|
{
|
|
m_pMouseDragItemPanel->SetVisible( false );
|
|
|
|
if( m_pDynamicRecipePanel )
|
|
{
|
|
m_pDynamicRecipePanel->SetVisible( false );
|
|
}
|
|
|
|
if ( m_pItemSlotPanel )
|
|
{
|
|
m_pItemSlotPanel->SetVisible( false );
|
|
}
|
|
|
|
m_bShowBaseItems = false;
|
|
if ( m_pShowBaseItemsCheckbox )
|
|
{
|
|
m_pShowBaseItemsCheckbox->SetSelected( m_bShowBaseItems );
|
|
}
|
|
|
|
if ( !bReturningFromArmory )
|
|
{
|
|
SetCurrentPage( 0 );
|
|
CancelToolSelection();
|
|
}
|
|
|
|
m_nNumActivePages = 0;
|
|
|
|
#ifdef STAGING_ONLY
|
|
// Reset pinned-state of the card
|
|
m_pMouseOverCardPanel->PinCard( false );
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
if ( m_bDragging )
|
|
{
|
|
StopDrag( false );
|
|
}
|
|
}
|
|
|
|
if ( m_pInspectPanel )
|
|
{
|
|
m_pInspectPanel->SetVisible( false );
|
|
}
|
|
|
|
if ( m_pInspectCosmeticPanel )
|
|
{
|
|
m_pInspectCosmeticPanel->SetVisible( false );
|
|
}
|
|
|
|
if ( m_pCollectionCraftPanel )
|
|
{
|
|
m_pCollectionCraftPanel->SetVisible( false );
|
|
}
|
|
|
|
if ( m_pHalloweenOfferingPanel )
|
|
{
|
|
m_pHalloweenOfferingPanel->SetVisible( false );
|
|
}
|
|
|
|
if ( m_pMannCoTradePanel )
|
|
{
|
|
m_pMannCoTradePanel->SetVisible( false );
|
|
}
|
|
|
|
if ( m_pStrangeToolPanel )
|
|
{
|
|
m_pStrangeToolPanel->MarkForDeletion();
|
|
m_pStrangeToolPanel = NULL;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::PostShowPanel( bool bVisible )
|
|
{
|
|
if ( bVisible )
|
|
{
|
|
DeSelectAllBackpackItemPanels();
|
|
|
|
RequestFocus();
|
|
|
|
// Clear out text field
|
|
ClearNameFilter( true );
|
|
}
|
|
|
|
// If this is the first time we've opened the loadout, start the loadout explanations
|
|
ConVar *pConVar = GetExplanationConVar();
|
|
if ( bVisible && pConVar && !pConVar->GetBool() && ShouldShowExplanations() )
|
|
{
|
|
m_flStartExplanationsAt = Plat_FloatTime() + 0.5;
|
|
vgui::ivgui()->AddTickSignal( GetVPanel() );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CBackpackPanel::GetNumPages( void )
|
|
{
|
|
int iMaxItems = InventoryManager()->GetLocalInventory()->GetMaxItemCount();
|
|
return (int)(ceil((float)iMaxItems / (float)BACKPACK_SLOTS_PER_PAGE));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::AssignItemToPanel( CItemModelPanel *pPanel, int iIndex )
|
|
{
|
|
tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
|
|
|
|
static int iItemBackpackPos = 0;
|
|
if ( iIndex == 0 )
|
|
{
|
|
iItemBackpackPos = 0;
|
|
}
|
|
int iPanelBackpackPos = GetBackpackPosForPanelIndex(iIndex);
|
|
|
|
static int iLastMapItem = -1;
|
|
|
|
pPanel->SetShowQuantity( true );
|
|
|
|
const wchar_t* wszFilter = GetNameFilter();
|
|
bool bInToolSelection = InToolSelectionMode() && m_ToolSelectionItem.IsValid();
|
|
|
|
CEconItemView *pItemData = NULL;
|
|
CEconItemView tempItem;
|
|
if ( m_bShowBaseItems )
|
|
{
|
|
const CEconItemDefinition* pItemDef = NULL;
|
|
|
|
const CEconItemSchema::BaseItemDefinitionMap_t& mapItems = GetItemSchema()->GetBaseItemDefinitionMap();
|
|
int iStart = iIndex == 0 ? mapItems.FirstInorder() : mapItems.NextInorder( iLastMapItem );
|
|
for ( int it = iStart; it != mapItems.InvalidIndex(); it = mapItems.NextInorder( it ) )
|
|
{
|
|
iLastMapItem = it;
|
|
|
|
if ( mapItems[it]->IsBaseItem() && !mapItems[it]->IsHidden() )
|
|
{
|
|
// Instead of linking to this base item definition, link to the definition of what it will become
|
|
// when we customize it.
|
|
CFmtStr fmtStrCustomizedDefName( "Upgradeable %s", mapItems[it]->GetDefinitionName() );
|
|
pItemDef = GetItemSchema()->GetItemDefinitionByName( fmtStrCustomizedDefName.Access() );
|
|
|
|
// If we don't have an upgradeable version, we assume that we can't upgrade it and link to the base
|
|
// definition instead. We expect this to only happen if the item won't actually be useable for whatever
|
|
// purpose (name tags, etc.). We sanity-check this on the GC.
|
|
if ( !pItemDef )
|
|
{
|
|
pItemDef = mapItems[it];
|
|
}
|
|
|
|
tempItem.Init( pItemDef->GetDefinitionIndex(), AE_UNIQUE, AE_USE_SCRIPT_VALUE, true );
|
|
|
|
// skip this item if the tool cannot be applied to it
|
|
if ( bInToolSelection && !CEconSharedToolSupport::ToolCanApplyTo( &m_ToolSelectionItem, &tempItem ) )
|
|
{
|
|
pItemDef = NULL;
|
|
continue;
|
|
}
|
|
|
|
if ( DoesItemPassSearchFilter( tempItem.GetDescription(), wszFilter ) )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
pItemDef = NULL;
|
|
}
|
|
|
|
if ( pItemDef )
|
|
{
|
|
pItemData = &tempItem;
|
|
|
|
++iItemBackpackPos;
|
|
}
|
|
}
|
|
else if ( HasNameFilter() )
|
|
{
|
|
int iStart = iIndex == 0 ? m_mapFilteringItems.FirstInorder() : m_mapFilteringItems.NextInorder( iLastMapItem );
|
|
for ( int it = iStart; it != m_mapFilteringItems.InvalidIndex(); it = m_mapFilteringItems.NextInorder( it ) )
|
|
{
|
|
iLastMapItem = it;
|
|
|
|
CEconItemView *pItem = m_mapFilteringItems[it];
|
|
|
|
// skip this item if the tool cannot be applied to it
|
|
if ( bInToolSelection && !CEconSharedToolSupport::ToolCanApplyTo( &m_ToolSelectionItem, pItem ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ( !DoesItemPassSearchFilter( pItem->GetDescription(), wszFilter ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ( ++iItemBackpackPos != iPanelBackpackPos )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
pItemData = pItem;
|
|
break;
|
|
}
|
|
}
|
|
else if ( bInToolSelection )
|
|
{
|
|
CPlayerInventory *pInventory = InventoryManager()->GetLocalInventory();
|
|
if ( pInventory )
|
|
{
|
|
// Backpack positions start from 1
|
|
Assert( iPanelBackpackPos > 0 && iPanelBackpackPos <= pInventory->GetMaxItemCount() );
|
|
int iStart = iIndex == 0 ? 0 : iLastMapItem + 1;
|
|
for ( int i = iStart; i < pInventory->GetItemCount(); i++ )
|
|
{
|
|
iLastMapItem = i;
|
|
|
|
CEconItemView *pItem = pInventory->GetItem(i);
|
|
|
|
if ( m_ToolSelectionItem.GetStaticData()->IsTool() )
|
|
{
|
|
if ( !CEconSharedToolSupport::ToolCanApplyTo( &m_ToolSelectionItem, pItem ) )
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( !pItem->GetStaticData()->IsTool() )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ( !CEconSharedToolSupport::ToolCanApplyTo( pItem, &m_ToolSelectionItem ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ( ( m_ToolSelectionItem.GetStaticData()->GetCapabilities() & ITEM_CAP_DECODABLE ) && pItem->GetStaticData()->GetEconTool() && ( Q_strcmp( pItem->GetStaticData()->GetEconTool()->GetTypeName(), "decoder_ring" ) != 0 ) )
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( ++iItemBackpackPos != iPanelBackpackPos )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
pItemData = pItem;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pItemData = InventoryManager()->GetItemByBackpackPosition( iPanelBackpackPos );
|
|
iItemBackpackPos = iPanelBackpackPos;
|
|
|
|
if ( pItemData == NULL && pPanel->GetItem() == NULL )
|
|
{
|
|
return;
|
|
}
|
|
|
|
int nDirtyIndex = pItemData ? m_vecDirtyItems.Find( pItemData->GetItemID() ) : m_vecDirtyItems.InvalidIndex();
|
|
|
|
if ( pItemData // Want to put in an item
|
|
&& pPanel->GetItem() // Panel has an item
|
|
&& pItemData->GetItemID() == pPanel->GetItem()->GetItemID() // That panel has the same item that we want to put in
|
|
&& nDirtyIndex == m_vecDirtyItems.InvalidIndex() ) // And that item is not dirtied.
|
|
{
|
|
// We dont do anything
|
|
return;
|
|
}
|
|
|
|
if ( nDirtyIndex != m_vecDirtyItems.InvalidIndex() )
|
|
{
|
|
m_vecDirtyItems.Remove( nDirtyIndex );
|
|
}
|
|
}
|
|
|
|
if ( iItemBackpackPos != iPanelBackpackPos )
|
|
{
|
|
pItemData = NULL;
|
|
}
|
|
|
|
pPanel->SetItem( pItemData );
|
|
|
|
bool bSeen = true;
|
|
// Have we not seen this item before?
|
|
if ( !m_bShowBaseItems && pItemData && m_mapSeenItems.Find( pItemData->GetItemID() ) == m_mapSeenItems.InvalidIndex() )
|
|
{
|
|
bSeen = false;
|
|
}
|
|
|
|
// Show our "NEW!" label if this item hasnt been seen
|
|
CExLabel *pNewPanel = dynamic_cast< CExLabel* >( pPanel->FindChildByName( "New" ) );
|
|
if ( pNewPanel )
|
|
{
|
|
pNewPanel->SetVisible( !bSeen );
|
|
}
|
|
|
|
pPanel->DirtyDescription();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::ClearNameFilter( bool bUpdateModelPanels )
|
|
{
|
|
if ( m_wNameFilter.Count() == 0 )
|
|
return;
|
|
|
|
m_wNameFilter.RemoveAll();
|
|
if( m_pNameFilterTextEntry )
|
|
{
|
|
m_pNameFilterTextEntry->SetText( "" );
|
|
}
|
|
|
|
if ( bUpdateModelPanels )
|
|
{
|
|
m_flFilterItemTime = gpGlobals->curtime + 0.1f;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::UpdateFilteringItems()
|
|
{
|
|
m_mapFilteringItems.RemoveAll();
|
|
|
|
if ( !HasNameFilter() )
|
|
return;
|
|
|
|
CPlayerInventory *pInventory = InventoryManager()->GetLocalInventory();
|
|
if ( !pInventory )
|
|
return;
|
|
|
|
for ( int i = 0; i < pInventory->GetItemCount(); i++ )
|
|
{
|
|
CEconItemView *pItem = pInventory->GetItem(i);
|
|
|
|
if ( pItem->GetItemDefinition()->IsHidden() )
|
|
continue;
|
|
|
|
int iBackpackPosition = InventoryManager()->GetBackpackPositionFromBackend( pItem->GetInventoryPosition() );
|
|
m_mapFilteringItems.Insert( iBackpackPosition, pItem );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::UpdateModelPanels( void )
|
|
{
|
|
tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s", __FUNCTION__ );
|
|
|
|
UpdateFilteringItems();
|
|
|
|
// We're showing the backpack. Show all the items in our inventory
|
|
FOR_EACH_VEC( m_pItemModelPanels, i )
|
|
{
|
|
m_pItemModelPanels[i]->SetShowEquipped( true );
|
|
m_pItemModelPanels[i]->SetShowGreyedOutTooltip( true );
|
|
AssignItemToPanel( m_pItemModelPanels[i], i );
|
|
|
|
if ( !m_pItemModelPanels[i]->HasItem() && m_pItemModelPanels[i]->IsSelected() )
|
|
{
|
|
m_pItemModelPanels[i]->SetSelected( false );
|
|
}
|
|
|
|
SetBorderForItem( m_pItemModelPanels[i], false );
|
|
}
|
|
|
|
// Clean out. We just did all the heavy lifting.
|
|
m_vecDirtyItems.Purge();
|
|
|
|
if ( InToolSelectionMode() && m_ToolSelectionItem.IsValid() )
|
|
{
|
|
wchar_t wTemp[256];
|
|
g_pVGuiLocalize->ConstructString_safe( wTemp, g_pVGuiLocalize->Find( "BackpackApplyTool" ), 1, m_ToolSelectionItem.GetItemName() );
|
|
SetDialogVariable( "loadoutclass", wTemp );
|
|
}
|
|
else
|
|
{
|
|
SetDialogVariable( "loadoutclass", g_pVGuiLocalize->Find( "BackpackTitle" ) );
|
|
}
|
|
|
|
char szTmp[16];
|
|
V_sprintf_safe( szTmp, "%d/%d", GetCurrentPage()+1, GetNumPages() );
|
|
SetDialogVariable( "backpackpage", szTmp );
|
|
|
|
// Now layout again to position our item buttons
|
|
InvalidateLayout();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Mark visited item model panels as seen
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnItemPanelEntered( vgui::Panel *panel )
|
|
{
|
|
if ( m_pContextMenu && m_pContextMenu->IsVisible() )
|
|
return;
|
|
|
|
CItemModelPanel *pItemPanel = dynamic_cast < CItemModelPanel * > ( panel );
|
|
if ( pItemPanel )
|
|
{
|
|
// Hide the "NEW!" label
|
|
CExLabel *pNewPanel = dynamic_cast< CExLabel* >( pItemPanel->FindChildByName( "New" ) );
|
|
if ( pNewPanel )
|
|
{
|
|
pNewPanel->SetVisible( false );
|
|
}
|
|
|
|
// Mark this item as "seen"
|
|
CEconItemView *pItem = pItemPanel->GetItem();
|
|
if ( pItem )
|
|
{
|
|
if ( m_mapSeenItems.Find( pItem->GetItemID() ) == m_mapSeenItems.InvalidIndex() )
|
|
{
|
|
m_mapSeenItems.Insert( pItem->GetItemID() );
|
|
SetPageButtonTextColorBasedOnContents();
|
|
}
|
|
}
|
|
}
|
|
|
|
BaseClass::OnItemPanelEntered( panel );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnItemPanelMousePressed( vgui::Panel *panel )
|
|
{
|
|
CItemModelPanel *pItemPanel = dynamic_cast < CItemModelPanel * > ( panel );
|
|
|
|
if ( pItemPanel && IsVisible() && pItemPanel->IsGreyedOut() == false && AllowDragging( pItemPanel ) )
|
|
{
|
|
m_flMouseDownTime = gpGlobals->curtime;
|
|
m_iMouseDownX = m_iMouseDownY = 0;
|
|
m_pItemDraggedFromPanel = pItemPanel;
|
|
m_iDraggedFromPage = GetCurrentPage();
|
|
m_bDragging = false;
|
|
m_bMouseDownOnItemPanel = true;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handle the escape key since it doesn't show up in OnKeyCodePressed
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnKeyCodeTyped(vgui::KeyCode code)
|
|
{
|
|
if ( code == KEY_ESCAPE && InToolSelectionMode() )
|
|
{
|
|
CancelToolSelection();
|
|
}
|
|
else if ( code == KEY_ENTER )
|
|
{
|
|
// Do nothing. This gets hit frequently when people type in the filter
|
|
// text entry and then hit 'Enter', expecting it to execute the filter.
|
|
// We automatically apply it, so let's just eat 'Enter', which was causing
|
|
// us to activate some button on the main menu.
|
|
}
|
|
else
|
|
{
|
|
BaseClass::OnKeyCodeTyped( code );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handles key press events in the backpack
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnKeyCodePressed( vgui::KeyCode code )
|
|
{
|
|
// Ignore key events while the confirm delete dialog is up
|
|
if( m_pConfirmDeleteDialog )
|
|
return;
|
|
|
|
// let our parent class handle all the arrow key/dpad stuff
|
|
if( HandleItemSelectionKeyPressed( code ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Handle close here, CBasePanel parent doesn't support "DialogClosing" command
|
|
ButtonCode_t nButtonCode = GetBaseButtonCode( code );
|
|
|
|
if ( (nButtonCode == KEY_XBUTTON_B || nButtonCode == STEAMCONTROLLER_B) && InToolSelectionMode() )
|
|
{
|
|
CancelToolSelection();
|
|
}
|
|
else if( code == KEY_PAGEDOWN )
|
|
{
|
|
OnCommand( "nextpage" );
|
|
}
|
|
else if( code == KEY_PAGEUP )
|
|
{
|
|
OnCommand( "prevpage" );
|
|
}
|
|
else if ( ( nButtonCode == KEY_XBUTTON_A || code == KEY_ENTER || nButtonCode == STEAMCONTROLLER_A ) )
|
|
{
|
|
if( InToolSelectionMode() )
|
|
{
|
|
HandleToolItemSelection( GetFirstSelectedItem() );
|
|
}
|
|
else
|
|
{
|
|
OpenContextMenu();
|
|
}
|
|
}
|
|
else if ( nButtonCode == KEY_XBUTTON_X || nButtonCode == STEAMCONTROLLER_X )
|
|
{
|
|
if( !InToolSelectionMode() )
|
|
{
|
|
OnCommand( "deleteitem" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BaseClass::OnKeyCodePressed( code );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handles key press events in the backpack
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnKeyCodeReleased( vgui::KeyCode code )
|
|
{
|
|
if( ! HandleItemSelectionKeyReleased( code ) )
|
|
BaseClass::OnKeyCodeReleased( code );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnMouseCaptureLost( void )
|
|
{
|
|
if ( m_bDragging )
|
|
{
|
|
StopDrag( false );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnMouseReleased(vgui::MouseCode code)
|
|
{
|
|
if ( code == MOUSE_LEFT )
|
|
{
|
|
if ( m_bDragging )
|
|
{
|
|
// When we're dragging, we have mouse capture, so the item panels aren't getting mouse input.
|
|
// We need to find out what item panel we're over, and let it know.
|
|
if ( m_pPrevDragOverItemPanel )
|
|
{
|
|
OnItemPanelMouseReleased( m_pPrevDragOverItemPanel );
|
|
}
|
|
else
|
|
{
|
|
StopDrag( false );
|
|
}
|
|
}
|
|
}
|
|
|
|
BaseClass::OnMouseReleased( code );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnConfirmDelete( KeyValues *data )
|
|
{
|
|
// Delete all the selected item
|
|
if ( data )
|
|
{
|
|
int iConfirmed = data->GetInt( "confirmed", 0 );
|
|
if ( iConfirmed )
|
|
{
|
|
for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
|
|
{
|
|
if ( m_pItemModelPanels[i]->IsSelected() && m_pItemModelPanels[i]->HasItem() )
|
|
{
|
|
EconUI()->Gamestats_ItemTransaction( IE_ITEM_DELETED, m_pItemModelPanels[i]->GetItem() );
|
|
InventoryManager()->DropItem( m_pItemModelPanels[i]->GetItem()->GetItemID() );
|
|
}
|
|
}
|
|
DeSelectAllBackpackItemPanels();
|
|
}
|
|
}
|
|
|
|
m_pConfirmDeleteDialog = NULL;
|
|
|
|
// If we're embedded in the discard item panel, it needs to know we made room. Send a message to our parent that it can catch.
|
|
PostMessage( GetParent(), new KeyValues("ConfirmDlgResult", "confirmed", 2 ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnItemPanelMouseReleased( vgui::Panel *panel )
|
|
{
|
|
CItemModelPanel *pItemPanel = dynamic_cast < CItemModelPanel * > ( panel );
|
|
|
|
if ( pItemPanel && IsVisible() )
|
|
{
|
|
if ( InToolSelectionMode() )
|
|
{
|
|
// They're selecting the item they'd like to apply a tool to
|
|
HandleToolItemSelection( pItemPanel->GetItem() );
|
|
}
|
|
else if ( !m_bDragging )
|
|
{
|
|
// If they're not holding down ctrl, deselect all existing selections
|
|
if ( !vgui::input()->IsKeyDown(KEY_LCONTROL) && !vgui::input()->IsKeyDown(KEY_RCONTROL) )
|
|
{
|
|
DeSelectAllBackpackItemPanels();
|
|
}
|
|
|
|
// Quick clicks just select the item
|
|
ToggleSelectBackpackItemPanel( pItemPanel );
|
|
|
|
if ( pItemPanel->IsSelected() )
|
|
{
|
|
OpenContextMenu();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int iPanelIndex = GetBackpackPositionForPanel( pItemPanel );
|
|
if ( !CanDragTo(pItemPanel, iPanelIndex) )
|
|
{
|
|
StopDrag(false);
|
|
}
|
|
else
|
|
{
|
|
StopDrag( true );
|
|
if ( (pItemPanel != m_pItemDraggedFromPanel || m_iDraggedFromPage != GetCurrentPage() ) && m_pMouseDragItemPanel->HasItem() )
|
|
{
|
|
HandleDragTo( pItemPanel, iPanelIndex );
|
|
}
|
|
else if ( m_iDraggedFromPage == GetCurrentPage() )
|
|
{
|
|
m_pItemDraggedFromPanel->SetItem( m_pMouseDragItemPanel->GetItem() );
|
|
}
|
|
}
|
|
}
|
|
|
|
m_pItemDraggedFromPanel = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
bool GetDecodedByItemDefIndex( const CEconItemView *pItem, uint32 *pDecodedBy = NULL )
|
|
{
|
|
static CSchemaAttributeDefHandle pAttrDef_DecodedBy( "decoded by itemdefindex" );
|
|
|
|
if ( pDecodedBy )
|
|
{
|
|
return pItem->FindAttribute( pAttrDef_DecodedBy, pDecodedBy );
|
|
}
|
|
else
|
|
{
|
|
return pItem->FindAttribute( pAttrDef_DecodedBy );
|
|
}
|
|
}
|
|
|
|
CEconItemView* GetFirstCompatibleKeyForCrate( const CEconItemView *pItem )
|
|
{
|
|
// Check if we have any decoder rings that can be applied onto this
|
|
CPlayerInventory *pInv = InventoryManager()->GetLocalInventory();
|
|
Assert( pInv );
|
|
if ( pInv )
|
|
{
|
|
for ( int i = 0; i < pInv->GetItemCount(); ++i )
|
|
{
|
|
CEconItemView *pInvItem = pInv->GetItem( i );
|
|
|
|
if ( pInvItem->GetQuality() == AE_SELFMADE )
|
|
continue;
|
|
|
|
if ( pInvItem->GetStaticData()->IsTool() && CEconSharedToolSupport::ToolCanApplyTo( pInvItem, pItem ) && pInvItem->GetStaticData()->GetEconTool() && ( Q_strcmp( pInvItem->GetStaticData()->GetEconTool()->GetTypeName(), "decoder_ring" ) == 0 ) )
|
|
{
|
|
return pInvItem;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool CanInventoryItemsApplyTo( const CEconItemView *pItem )
|
|
{
|
|
// Check if we have any tools that can be applied onto this
|
|
CPlayerInventory *pInv = InventoryManager()->GetLocalInventory();
|
|
Assert( pInv );
|
|
if ( pInv )
|
|
{
|
|
for ( int i = 0 ; i < pInv->GetItemCount() ; ++i )
|
|
{
|
|
CEconItemView *pInvItem = pInv->GetItem( i );
|
|
if ( pInvItem->GetStaticData()->IsTool() && CEconSharedToolSupport::ToolCanApplyTo( pInvItem, pItem ) )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
bool CreateMarketPriceString( item_definition_index_t iDefIndex, wchar_t *pszString, int iBufferSize )
|
|
{
|
|
// Get Market Price
|
|
steam_market_gc_identifier_t ident;
|
|
ident.m_unDefIndex = iDefIndex;
|
|
ident.m_unQuality = AE_UNIQUE; // Get this from default item def?
|
|
|
|
const client_market_data_t *pClientMarketData = GetClientMarketData( ident );
|
|
if ( !pClientMarketData )
|
|
return false;
|
|
|
|
const ECurrency eCurrency = EconUI()->GetStorePanel()->GetCurrency();
|
|
|
|
// Set that price into the button
|
|
wchar_t pszCurrencyString[kLocalizedPriceSizeInChararacters];
|
|
MakeMoneyString( pszCurrencyString, ARRAYSIZE( pszCurrencyString ), pClientMarketData->m_unLowestPrice, eCurrency );
|
|
|
|
wchar_t pszConstructed[kLocalizedPriceSizeInChararacters];
|
|
g_pVGuiLocalize->ConstructString_safe( pszConstructed, g_pVGuiLocalize->Find( "#TF_MarketPrice" ), 1, pszCurrencyString );
|
|
|
|
// copy result;
|
|
V_wcsncpy( pszString, pszConstructed, iBufferSize );
|
|
return true;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
bool CreateStorePriceString( item_definition_index_t iDefIndex, wchar_t *pszString, int iBufferSize )
|
|
{
|
|
// Get Market Price
|
|
steam_market_gc_identifier_t ident;
|
|
ident.m_unDefIndex = iDefIndex;
|
|
ident.m_unQuality = AE_UNIQUE; // Get this from default item def?
|
|
|
|
// Get the price of the item
|
|
const econ_store_entry_t *pEntry = EconUI()->GetStorePanel()->GetPriceSheet()->GetEntry( iDefIndex );
|
|
if ( !pEntry )
|
|
return false;
|
|
|
|
const ECurrency eCurrency = EconUI()->GetStorePanel()->GetCurrency();
|
|
|
|
// Set that price into the button
|
|
wchar_t pszCurrencyString[kLocalizedPriceSizeInChararacters];
|
|
MakeMoneyString( pszCurrencyString, ARRAYSIZE( pszCurrencyString ), pEntry->GetCurrentPrice( eCurrency ), eCurrency );
|
|
|
|
wchar_t pszConstructed[kLocalizedPriceSizeInChararacters];
|
|
g_pVGuiLocalize->ConstructString_safe( pszConstructed, g_pVGuiLocalize->Find( "#TF_StorePrice" ), 1, pszCurrencyString );
|
|
|
|
// copy result;
|
|
V_wcsncpy( pszString, pszConstructed, iBufferSize );
|
|
return true;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::AddCommerceSubmenus( Menu *pSubMenu, item_definition_index_t iItemDef, const char* pszActionFmt )
|
|
{
|
|
wchar_t wPriceListing[256];
|
|
// Store
|
|
if ( CreateStorePriceString( iItemDef, wPriceListing, sizeof( wPriceListing ) ) )
|
|
{
|
|
int nIndex = pSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", CFmtStr( "%s%s%d", "store_", pszActionFmt, iItemDef ) ), this );
|
|
vgui::MenuItem *pMenuItem = pSubMenu->GetMenuItem( nIndex );
|
|
pMenuItem->SetText( wPriceListing );
|
|
pMenuItem->InvalidateLayout( true, false );
|
|
}
|
|
|
|
// Market
|
|
if ( CreateMarketPriceString( iItemDef, wPriceListing, sizeof( wPriceListing ) ) )
|
|
{
|
|
int nIndex = pSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", CFmtStr( "%s%s%d", "market_", pszActionFmt, iItemDef ) ), this );
|
|
vgui::MenuItem *pMenuItem = pSubMenu->GetMenuItem( nIndex );
|
|
pMenuItem->SetText( wPriceListing );
|
|
pMenuItem->InvalidateLayout( true, false );
|
|
}
|
|
else
|
|
{
|
|
int nIndex = pSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", CFmtStr( "%s%s%d", "market_", pszActionFmt, iItemDef ) ), this );
|
|
vgui::MenuItem *pMenuItem = pSubMenu->GetMenuItem( nIndex );
|
|
pMenuItem->SetText( g_pVGuiLocalize->Find( "#TF_MarketUnavailable" ) );
|
|
pMenuItem->InvalidateLayout( true, false );
|
|
}
|
|
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::AddPaintToContextMenu( Menu *pPaintSubMenu, item_definition_index_t iPaintDef, bool bAddCommerce )
|
|
{
|
|
GameItemDefinition_t * pPaintCanDef = dynamic_cast<GameItemDefinition_t*>( GEconItemSchema().GetItemDefinition( iPaintDef ) );
|
|
if ( !pPaintCanDef )
|
|
return;
|
|
|
|
wchar_t wBuff[256];
|
|
char cBuff[256];
|
|
V_swprintf_safe( wBuff, L" %ls", g_pVGuiLocalize->Find( pPaintCanDef->GetItemBaseName() ) );
|
|
|
|
char szItemName[256];
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find( pPaintCanDef->GetItemBaseName() ), szItemName, sizeof( szItemName ) );
|
|
V_sprintf_safe( cBuff, " %s", szItemName );
|
|
|
|
uint32 unPaintRGB0 = 0;
|
|
uint32 unPaintRGB1 = 0;
|
|
|
|
static CSchemaAttributeDefHandle pAttrDef_PaintRGB( "set item tint RGB" );
|
|
static CSchemaAttributeDefHandle pAttrDef_PaintRGB2( "set item tint RGB 2" );
|
|
|
|
float fRGB = 0.0f;
|
|
|
|
if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pPaintCanDef, pAttrDef_PaintRGB, &fRGB ) && fRGB != 0.0f )
|
|
{
|
|
unPaintRGB0 = fRGB;
|
|
|
|
// We may or may not have a secondary paint color as well. If we don't, we just use the primary
|
|
// paint color to fill both slots.
|
|
if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pPaintCanDef, pAttrDef_PaintRGB2, &fRGB ) )
|
|
{
|
|
unPaintRGB1 = fRGB;
|
|
}
|
|
else
|
|
{
|
|
unPaintRGB1 = unPaintRGB0;
|
|
}
|
|
}
|
|
|
|
if ( !bAddCommerce )
|
|
{
|
|
int nIndex = pPaintSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", CFmtStr( "paint%d", iPaintDef ) ), this );
|
|
vgui::MenuItem *pMenuItem = pPaintSubMenu->GetMenuItem( nIndex );
|
|
pMenuItem->SetText( wBuff );
|
|
pMenuItem->InvalidateLayout( true, false );
|
|
|
|
CItemMaterialCustomizationIconPanel *pCustomPanel = new CItemMaterialCustomizationIconPanel( pMenuItem, "paint" );
|
|
pCustomPanel->SetZPos( -100 );
|
|
pCustomPanel->SetTall( 30 );
|
|
pCustomPanel->SetWide( 30 );
|
|
pCustomPanel->m_colPaintColors.AddToTail( Color( clamp( ( unPaintRGB0 & 0xFF0000 ) >> 16, 0, 255 ), clamp( ( unPaintRGB0 & 0xFF00 ) >> 8, 0, 255 ), clamp( ( unPaintRGB0 & 0xFF ), 0, 255 ), 255 ) );
|
|
pCustomPanel->m_colPaintColors.AddToTail( Color( clamp( ( unPaintRGB1 & 0xFF0000 ) >> 16, 0, 255 ), clamp( ( unPaintRGB1 & 0xFF00 ) >> 8, 0, 255 ), clamp( ( unPaintRGB1 & 0xFF ), 0, 255 ), 255 ) );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
const char *pszContextMenuBorder = "NotificationDefault";
|
|
const char *pszContextMenuFont = "HudFontMediumSecondary";
|
|
|
|
Menu *pSubMenu = new Menu( this, "PaintSubMenu" );
|
|
pSubMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
|
|
pSubMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );
|
|
int iPos = pPaintSubMenu->AddCascadingMenuItem( cBuff, this, pSubMenu );
|
|
|
|
CItemMaterialCustomizationIconPanel *pCustomPanel = new CItemMaterialCustomizationIconPanel( pPaintSubMenu, "paint" );
|
|
pCustomPanel->SetZPos( 100 );
|
|
pCustomPanel->SetPos( 0, iPos * pPaintSubMenu->GetMenuItemHeight() );
|
|
pCustomPanel->SetTall( 30 );
|
|
pCustomPanel->SetWide( 30 );
|
|
pCustomPanel->m_colPaintColors.AddToTail( Color( clamp( ( unPaintRGB0 & 0xFF0000 ) >> 16, 0, 255 ), clamp( ( unPaintRGB0 & 0xFF00 ) >> 8, 0, 255 ), clamp( ( unPaintRGB0 & 0xFF ), 0, 255 ), 255 ) );
|
|
pCustomPanel->m_colPaintColors.AddToTail( Color( clamp( ( unPaintRGB1 & 0xFF0000 ) >> 16, 0, 255 ), clamp( ( unPaintRGB1 & 0xFF00 ) >> 8, 0, 255 ), clamp( ( unPaintRGB1 & 0xFF ), 0, 255 ), 255 ) );
|
|
|
|
AddCommerceSubmenus( pSubMenu, iPaintDef, "paint" );
|
|
}
|
|
}
|
|
//
|
|
// Add commerce context options for an item. Adds 'Store' and 'Market' options if appropriate (and Pricing) other wise just click to use
|
|
//
|
|
void CBackpackPanel::AddCommerceToContextMenu( Menu *pMenu, const char* pszActionFmt, item_definition_index_t iItemDefIndex, bool bAddMarket, bool bAddStore )
|
|
{
|
|
GameItemDefinition_t * pItemDef = dynamic_cast<GameItemDefinition_t*>( GEconItemSchema().GetItemDefinition( iItemDefIndex ) );
|
|
if ( !pItemDef )
|
|
return;
|
|
|
|
//
|
|
if ( !bAddMarket && !bAddStore )
|
|
{
|
|
int nIndex = pMenu->AddMenuItem( "", new KeyValues( "Command", "command", CFmtStr( "%s%d", pszActionFmt, iItemDefIndex ) ), this );
|
|
vgui::MenuItem *pMenuItem = pMenu->GetMenuItem( nIndex );
|
|
pMenuItem->SetText( g_pVGuiLocalize->Find( pItemDef->GetItemBaseName() ) );
|
|
pMenuItem->InvalidateLayout( true, false );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
const char *pszContextMenuBorder = "NotificationDefault";
|
|
const char *pszContextMenuFont = "HudFontMediumSecondary";
|
|
|
|
Menu *pSubMenu = new Menu( this, "CommerceSubMenu" );
|
|
pSubMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
|
|
pSubMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );
|
|
pMenu->AddCascadingMenuItem( pItemDef->GetItemBaseName(), this, pSubMenu );
|
|
|
|
AddCommerceSubmenus( pSubMenu, iItemDefIndex, pszActionFmt );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Opens a context menu with actions relevant for the passed in item
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OpenContextMenu()
|
|
{
|
|
CUtlVector<CEconItemView*> vecSelectedItems;
|
|
for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
|
|
{
|
|
if ( m_pItemModelPanels[i]->IsSelected() && m_pItemModelPanels[i]->GetItem() )
|
|
{
|
|
vecSelectedItems.AddToTail( m_pItemModelPanels[i]->GetItem() );
|
|
}
|
|
}
|
|
|
|
if ( m_pContextMenu )
|
|
delete m_pContextMenu;
|
|
|
|
m_pContextMenu = new Menu( this, "ContextMenu" );
|
|
MenuBuilder contextMenuBuilder( m_pContextMenu, this );
|
|
const char *pszContextMenuBorder = "NotificationDefault";
|
|
const char *pszContextMenuFont = "HudFontMediumSecondary";
|
|
m_pContextMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
|
|
m_pContextMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );
|
|
|
|
if ( vecSelectedItems.Count() == 1 )
|
|
{
|
|
const CEconItemView *pItem = vecSelectedItems.Head();
|
|
const CTFItemDefinition *pItemDef = pItem->GetStaticData();
|
|
static CSchemaItemDefHandle DuckBadgeItemDef( "Duck Badge" );
|
|
static CSchemaItemDefHandle StrangeCountTransferItemDef( "Strange Count Transfer Tool" );
|
|
|
|
// Tools of any kind can't be used if they are in escrow.
|
|
static CSchemaAttributeDefHandle pAttrib_ToolEscrowUntil( "tool escrow until date" );
|
|
uint32 unEscrowTime;
|
|
const bool bToolIsInEscrow = pItem->FindAttribute( pAttrib_ToolEscrowUntil, &unEscrowTime )
|
|
&& unEscrowTime > CRTime::RTime32TimeCur();
|
|
|
|
const IEconTool *pEconTool = pItem->GetItemDefinition()->GetEconTool();
|
|
|
|
const bool bIsTool = pItem->GetStaticData()->IsTool() && (pEconTool != NULL);
|
|
const bool bIsGCConsumable = ( ( pItem->GetStaticData()->GetCapabilities() & ITEM_CAP_USABLE_GC ) != 0 );
|
|
bool bSkipAddTrade = false; // Hack: We should really ask the tool if the command supplants trade.
|
|
|
|
// Tool usage goes first. The cursor starts on this element, so double-clicks will work like how they used to.
|
|
// Strange Count Transfer
|
|
if ( StrangeCountTransferItemDef == pItem->GetItemDefinition() )
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#ApplyOnItem", new KeyValues( "Context_OpenStrangeCountTransfer" ), "primaryaction" );
|
|
}
|
|
else if ( pItem->GetStaticData()->IsTool() && pEconTool == NULL )
|
|
{
|
|
// do nothing. not a real tool (basic balloons with color that we don't want to 'remove' the paint)
|
|
}
|
|
else if ( (bIsTool || bIsGCConsumable) && !bToolIsInEscrow && pEconTool->CanBeUsedNow( pItem ) )
|
|
{
|
|
Assert( pEconTool );
|
|
|
|
const int nTokens = pEconTool->GetUseCommandCount( pItem );
|
|
for ( int i = 0; i < nTokens; ++i )
|
|
{
|
|
const char *pszToolUsageString = pEconTool->GetUseCommandLocalizationToken( pItem, i );
|
|
|
|
// If we didn't have a custom usage string, fall back to a sane default based on whether or
|
|
// not we're a consumable or not.
|
|
if ( !pszToolUsageString )
|
|
{
|
|
pszToolUsageString = bIsGCConsumable ? "#ConsumeItem" : "#ApplyOnItem";
|
|
}
|
|
|
|
const char *pszContext = pEconTool->GetUseCommand( pItem, i );
|
|
contextMenuBuilder.AddMenuItem( pszToolUsageString, new KeyValues( pszContext ), "primaryaction" );
|
|
}
|
|
|
|
// Hack: We should really ask the tool if the command supplants trade. For now, if we have two
|
|
// things, then one of them is trade, so skip it.
|
|
bSkipAddTrade = nTokens > 1;
|
|
}
|
|
else if ( pItem->GetItemDefinition()->GetCapabilities() & ITEM_CAP_DECODABLE )
|
|
{
|
|
|
|
static CSchemaAttributeDefHandle pAttrDef_CanShuffleCrateContents( "can shuffle crate contents" );
|
|
|
|
if ( pItem->FindAttribute( pAttrDef_CanShuffleCrateContents ) )
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#ShuffleContents", new KeyValues( "Context_Shuffle" ), "primaryaction" );
|
|
}
|
|
|
|
if ( GetFirstCompatibleKeyForCrate( pItem ) != NULL )
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#UseKey", new KeyValues( "Context_OpenCrateWithKey" ), "primaryaction" );
|
|
}
|
|
|
|
if ( GetDecodedByItemDefIndex( pItem ) )
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#GetKey", new KeyValues( "Context_GetItemFromStore" ), "primaryaction" );
|
|
contextMenuBuilder.AddMenuItem( "#BuyAndUseKey", new KeyValues( "Context_BuyKeyAndOpenCrate" ), "primaryaction" );
|
|
}
|
|
}
|
|
else if ( pItem->GetItemDefinition()->GetCapabilities() & ITEM_CAP_HAS_SLOTS )
|
|
{
|
|
// check if we have at least 1 slot criteria
|
|
static CSchemaAttributeDefHandle pAttrDef_Slot( "item slot criteria 1" );
|
|
if ( pItem->FindAttribute( pAttrDef_Slot ) )
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#EditSlots", new KeyValues( "Context_EditSlot" ), "primaryaction" );
|
|
}
|
|
}
|
|
else if ( DuckBadgeItemDef == pItem->GetItemDefinition() )
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#Duck_ViewLeaderboards", new KeyValues( "Context_OpenDuckLeaderboards" ), "primaryaction" );
|
|
|
|
if ( CanInventoryItemsApplyTo( pItem ) )
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#UseDuckToken", new KeyValues( "Context_ApplyByItem" ), "primaryaction" );
|
|
}
|
|
|
|
if ( GetDecodedByItemDefIndex( pItem ) )
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#GetDuckToken", new KeyValues( "Context_GetItemFromStore" ), "primaryaction" );
|
|
}
|
|
}
|
|
|
|
// 3D Inspect
|
|
float flInspect = 0;
|
|
static CSchemaAttributeDefHandle pAttrib_WeaponAllowInspect( "weapon_allow_inspect" );
|
|
static CSchemaAttributeDefHandle pAttrib_CosmeticAllowInspect( "cosmetic_allow_inspect" );
|
|
if ( pItem && pItem->IsValid() &&
|
|
( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pAttrib_WeaponAllowInspect, &flInspect ) || FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pAttrib_CosmeticAllowInspect, &flInspect )
|
|
#ifdef STAGING_ONLY
|
|
|| tf_weapon_force_allow_inspect.GetBool()
|
|
#endif
|
|
) )
|
|
{
|
|
if ( flInspect != 0
|
|
#ifdef STAGING_ONLY
|
|
|| tf_weapon_force_allow_inspect.GetBool()
|
|
#endif
|
|
)
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#Context_InspectModel", new KeyValues( "Context_InspectModel" ), "primaryaction" );
|
|
}
|
|
}
|
|
|
|
// Add equip sub menu
|
|
{
|
|
Menu *pEquipSubMenu = NULL;
|
|
for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_LAST_NORMAL_CLASS; iClass++ )
|
|
{
|
|
if ( !pItemDef->CanBeUsedByClass( iClass ) )
|
|
continue;
|
|
|
|
if ( pEquipSubMenu == NULL )
|
|
{
|
|
pEquipSubMenu = new Menu( this, "EquipMenu" );
|
|
pEquipSubMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
|
|
pEquipSubMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );
|
|
|
|
contextMenuBuilder.AddCascadingMenuItem( "#Context_Equip", pEquipSubMenu, "primaryaction" );
|
|
}
|
|
|
|
const char *pszClassName = NULL;
|
|
switch ( iClass )
|
|
{
|
|
case TF_CLASS_SCOUT: pszClassName = "#TF_Class_Name_Scout"; break;
|
|
case TF_CLASS_SNIPER: pszClassName = "#TF_Class_Name_Sniper"; break;
|
|
case TF_CLASS_SOLDIER: pszClassName = "#TF_Class_Name_Soldier"; break;
|
|
case TF_CLASS_DEMOMAN: pszClassName = "#TF_Class_Name_Demoman"; break;
|
|
case TF_CLASS_MEDIC: pszClassName = "#TF_Class_Name_Medic"; break;
|
|
case TF_CLASS_HEAVYWEAPONS: pszClassName = "#TF_Class_Name_HWGuy"; break;
|
|
case TF_CLASS_PYRO: pszClassName = "#TF_Class_Name_Pyro"; break;
|
|
case TF_CLASS_SPY: pszClassName = "#TF_Class_Name_Spy"; break;
|
|
case TF_CLASS_ENGINEER: pszClassName = "#TF_Class_Name_Engineer"; break;
|
|
}
|
|
|
|
pEquipSubMenu->AddMenuItem( pszClassName, new KeyValues( "Command", "command", CFmtStr( "equipclass%d", iClass ) ), this );
|
|
}
|
|
}
|
|
|
|
// For customizable items only
|
|
if ( !pItem->IsTemporaryItem() )
|
|
{
|
|
bool bCanCraftUp = GetCollectionCraftingInvalidReason(pItem, NULL) == NULL;
|
|
bool bCanStatClockTrade = GetCraftCommonStatClockInvalidReason(pItem, NULL) == NULL;
|
|
Menu *pMannCoTradeSubMenu = NULL;
|
|
|
|
if ( bCanCraftUp || bCanStatClockTrade )
|
|
{
|
|
pMannCoTradeSubMenu = new Menu(this, "MannCoTradeSubMenu");
|
|
pMannCoTradeSubMenu->SetBorder(scheme()->GetIScheme(GetScheme())->GetBorder(pszContextMenuBorder));
|
|
pMannCoTradeSubMenu->SetFont(scheme()->GetIScheme(GetScheme())->GetFont(pszContextMenuFont));
|
|
contextMenuBuilder.AddCascadingMenuItem("#Context_MannCoTrade", pMannCoTradeSubMenu, "customization");
|
|
|
|
if ( bCanCraftUp )
|
|
{
|
|
int nIndex = pMannCoTradeSubMenu->AddMenuItem("", new KeyValues("Command", "command", "Context_CraftUpCollection"), this);
|
|
vgui::MenuItem *pMenuItem = pMannCoTradeSubMenu->GetMenuItem(nIndex);
|
|
pMenuItem->SetText("#Context_TradeUp");
|
|
pMenuItem->InvalidateLayout(true, false);
|
|
}
|
|
|
|
if ( bCanStatClockTrade )
|
|
{
|
|
int nIndex = pMannCoTradeSubMenu->AddMenuItem("", new KeyValues("Command", "command", "Context_CraftCommonStatClock"), this);
|
|
vgui::MenuItem *pMenuItem = pMannCoTradeSubMenu->GetMenuItem(nIndex);
|
|
pMenuItem->SetText("#Context_CommonStatClock");
|
|
pMenuItem->InvalidateLayout(true, false);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Campaign coin access trades
|
|
static CSchemaAttributeDefHandle pAttrDef_IsOperationPass( "is_operation_pass" );
|
|
if ( pItem->FindAttribute( pAttrDef_IsOperationPass ) )
|
|
{
|
|
Menu *pMannCoCoinTradeSubMenu = new Menu( this, "MannCoTradeSubMenu" );
|
|
pMannCoCoinTradeSubMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
|
|
pMannCoCoinTradeSubMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );
|
|
contextMenuBuilder.AddCascadingMenuItem( "#Context_MannCoTrade", pMannCoCoinTradeSubMenu, "customization" );
|
|
|
|
int nIndex = pMannCoCoinTradeSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", "Context_CraftUpCollection" ), this );
|
|
vgui::MenuItem *pMenuItem = pMannCoCoinTradeSubMenu->GetMenuItem( nIndex );
|
|
pMenuItem->SetText( "#Context_TradeUp" );
|
|
pMenuItem->InvalidateLayout( true, false );
|
|
|
|
nIndex = pMannCoCoinTradeSubMenu->AddMenuItem("", new KeyValues("Command", "command", "Context_CraftCommonStatClock"), this);
|
|
pMenuItem = pMannCoCoinTradeSubMenu->GetMenuItem(nIndex);
|
|
pMenuItem->SetText("#Context_CommonStatClock");
|
|
pMenuItem->InvalidateLayout(true, false);
|
|
}
|
|
|
|
// Halloween trade up offering.
|
|
// Needs two attrs
|
|
static CSchemaAttributeDefHandle pAttrDef_HalloweenOffering( "allow_halloween_offering" );
|
|
static CSchemaAttributeDefHandle pAttrDef_DeactiveDate( "deactive date" );
|
|
|
|
// Check the date
|
|
uint32 unDeactiveDate = 0;
|
|
uint32 unCurrentDate = CRTime::RTime32TimeCur();
|
|
if ( pAttrDef_HalloweenOffering && pItem->FindAttribute( pAttrDef_HalloweenOffering ) && pItem->FindAttribute( pAttrDef_DeactiveDate, &unDeactiveDate ) && unDeactiveDate > unCurrentDate )
|
|
{
|
|
vgui::MenuItem *pMenuItem = contextMenuBuilder.AddMenuItem( "#Context_HalloweenOffering", new KeyValues( "Context_HalloweenOffering" ), "customization" );
|
|
|
|
ImagePanel *pNewImage = new ImagePanel( pMenuItem, "new" );
|
|
pNewImage->SetZPos( 100 );
|
|
pNewImage->SetWide( 40 );
|
|
pNewImage->SetTall( 40 );
|
|
pNewImage->SetPos( 220, -5 );
|
|
pNewImage->SetMouseInputEnabled( false );
|
|
pNewImage->SetShouldScaleImage( true );
|
|
pNewImage->SetImage( "new" );
|
|
}
|
|
|
|
// Change name
|
|
GameItemDefinition_t * pNameTagDef = dynamic_cast<GameItemDefinition_t*>( GEconItemSchema().GetItemDefinitionByName( "Name Tag" ) );
|
|
if ( CEconSharedToolSupport::ToolCanApplyToDefinition( dynamic_cast<const GameItemDefinition_t *>( pNameTagDef ), pItemDef ) )
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#Context_Rename", new KeyValues( "DoRename" ), "customization" );
|
|
}
|
|
|
|
// Change description
|
|
GameItemDefinition_t * pDescTagDef = dynamic_cast<GameItemDefinition_t*>( GEconItemSchema().GetItemDefinitionByName( "Description Tag" ) );
|
|
if ( CEconSharedToolSupport::ToolCanApplyToDefinition( dynamic_cast<const GameItemDefinition_t *>( pDescTagDef ), pItemDef ) )
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#Context_Description", new KeyValues( "DoDescription" ), "customization" );
|
|
}
|
|
|
|
// Add paint options sub menu
|
|
if ( m_vecPaintCans.Count() > 0 )
|
|
{
|
|
GameItemDefinition_t * pPaintCanDef = dynamic_cast<GameItemDefinition_t*>( GEconItemSchema().GetItemDefinition( m_vecPaintCans[0] ) );
|
|
if ( pPaintCanDef && CEconSharedToolSupport::ToolCanApplyToDefinition( dynamic_cast<const GameItemDefinition_t *>( pPaintCanDef ), pItemDef ) )
|
|
{
|
|
Menu *pPaintSubMenu = NULL;
|
|
pPaintSubMenu = new Menu( this, "PaintSubMenu" );
|
|
pPaintSubMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
|
|
pPaintSubMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );
|
|
contextMenuBuilder.AddCascadingMenuItem( "#Context_Paint", pPaintSubMenu, "customization" );
|
|
|
|
CUtlVector<item_definition_index_t> vecOwnedPaints;
|
|
CUtlVector<item_definition_index_t> vecStorePaints;
|
|
|
|
// Find out if the user owns this item or not and place in the proper bucket
|
|
CPlayerInventory *pLocalInv = TFInventoryManager()->GetLocalInventory();
|
|
|
|
FOR_EACH_VEC( m_vecPaintCans, i )
|
|
{
|
|
if ( pLocalInv && pLocalInv->FindFirstItembyItemDef( m_vecPaintCans[i] ) )
|
|
{
|
|
vecOwnedPaints.AddToTail( m_vecPaintCans[i] );
|
|
}
|
|
else
|
|
{
|
|
vecStorePaints.AddToTail( m_vecPaintCans[i] );
|
|
}
|
|
}
|
|
|
|
if ( vecOwnedPaints.Count() > 0 )
|
|
{
|
|
// Add Header and loop
|
|
int nIndex = pPaintSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", "" ), this );
|
|
vgui::MenuItem *pMenuItem = pPaintSubMenu->GetMenuItem( nIndex );
|
|
pMenuItem->SetText( g_pVGuiLocalize->Find( "#TF_Owned" ) );
|
|
pMenuItem->InvalidateLayout( true, false );
|
|
|
|
FOR_EACH_VEC( vecOwnedPaints, i )
|
|
{
|
|
AddPaintToContextMenu( pPaintSubMenu, vecOwnedPaints[i], false );
|
|
}
|
|
}
|
|
|
|
pPaintSubMenu->AddSeparator();
|
|
if ( vecStorePaints.Count() > 0 )
|
|
{
|
|
// Add Header and loop
|
|
int nIndex = pPaintSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", "" ), this );
|
|
vgui::MenuItem *pMenuItem = pPaintSubMenu->GetMenuItem( nIndex );
|
|
pMenuItem->SetText( g_pVGuiLocalize->Find( "#TF_Commerce" ) );
|
|
pMenuItem->InvalidateLayout( true, false );
|
|
|
|
FOR_EACH_VEC( vecStorePaints, i )
|
|
{
|
|
AddPaintToContextMenu( pPaintSubMenu, vecStorePaints[i], true );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Strange Parts
|
|
if ( BIsItemStrange( pItem ) )
|
|
{
|
|
Menu *pStrangePartsSubMenu = NULL;
|
|
CUtlVector<item_definition_index_t> vecOwnedParts;
|
|
CUtlVector<item_definition_index_t> vecStoreParts;
|
|
|
|
// Find out if the user owns this item or not and place in the proper bucket
|
|
CPlayerInventory *pLocalInv = TFInventoryManager()->GetLocalInventory();
|
|
FOR_EACH_VEC( m_vecStrangeParts, i )
|
|
{
|
|
// Determine if this can be applied
|
|
//GameItemDefinition_t *pStrangePartDef = dynamic_cast<GameItemDefinition_t*>( GEconItemSchema().GetItemDefinition( m_vecStrangeParts[i] ) );
|
|
CEconItemView partItemView;
|
|
partItemView.Init( m_vecStrangeParts[i], AE_USE_SCRIPT_VALUE, 1 );
|
|
if ( CEconSharedToolSupport::ToolCanApplyTo( &partItemView, pItem ) )
|
|
{
|
|
// Create menu
|
|
if ( !pStrangePartsSubMenu )
|
|
{
|
|
pStrangePartsSubMenu = new Menu( this, "StrangePartsSubMenu" );
|
|
pStrangePartsSubMenu->SetBorder( scheme()->GetIScheme( GetScheme() )->GetBorder( pszContextMenuBorder ) );
|
|
pStrangePartsSubMenu->SetFont( scheme()->GetIScheme( GetScheme() )->GetFont( pszContextMenuFont ) );
|
|
contextMenuBuilder.AddCascadingMenuItem( "#Context_StrangeParts", pStrangePartsSubMenu, "customization" );
|
|
}
|
|
|
|
if ( pLocalInv && pLocalInv->FindFirstItembyItemDef( m_vecStrangeParts[i] ) )
|
|
{
|
|
vecOwnedParts.AddToTail( m_vecStrangeParts[i] );
|
|
}
|
|
else
|
|
{
|
|
vecStoreParts.AddToTail( m_vecStrangeParts[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( pStrangePartsSubMenu )
|
|
{
|
|
if ( vecOwnedParts.Count() > 0 )
|
|
{
|
|
// Add Header and loop
|
|
int nIndex = pStrangePartsSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", "" ), this );
|
|
vgui::MenuItem *pMenuItem = pStrangePartsSubMenu->GetMenuItem( nIndex );
|
|
pMenuItem->SetText( g_pVGuiLocalize->Find( "#TF_Owned" ) );
|
|
pMenuItem->InvalidateLayout( true, false );
|
|
|
|
FOR_EACH_VEC( vecOwnedParts, i )
|
|
{
|
|
AddCommerceToContextMenu( pStrangePartsSubMenu, "strangepart_", vecOwnedParts[i], false, false );
|
|
}
|
|
}
|
|
|
|
pStrangePartsSubMenu->AddSeparator();
|
|
if ( vecStoreParts.Count() > 0 )
|
|
{
|
|
// Add Header and loop
|
|
int nIndex = pStrangePartsSubMenu->AddMenuItem( "", new KeyValues( "Command", "command", "" ), this );
|
|
vgui::MenuItem *pMenuItem = pStrangePartsSubMenu->GetMenuItem( nIndex );
|
|
pMenuItem->SetText( g_pVGuiLocalize->Find( "#TF_Market" ) );
|
|
pMenuItem->InvalidateLayout( true, false );
|
|
|
|
FOR_EACH_VEC( vecStoreParts, i )
|
|
{
|
|
AddCommerceToContextMenu( pStrangePartsSubMenu, "strangepart_", vecStoreParts[i], true, false );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( pItem->IsMarketable() )
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#Context_MarketPlaceSell", new KeyValues( "DoSellMarketplace" ), "economy" );
|
|
}
|
|
|
|
// Trade to another player
|
|
if ( pItem->IsTradable() && !bSkipAddTrade )
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#Context_Trade", new KeyValues( "DoTradeToPlayer" ), "economy" );
|
|
}
|
|
|
|
if ( pItem->GetItemDefinition()->GetCapabilities() & ITEM_CAP_CAN_BE_RESTORED )
|
|
{
|
|
if ( RemovableAttributes_DoAnyAttributesApply( pItem ) )
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#RefurbishItem", new KeyValues( "Context_RefurbishItem" ), "destructive" );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Check if ALL selected items can be crafted together
|
|
bool bCanCraftUp = true;
|
|
for( int i=0; i < COLLECTION_CRAFTING_ITEM_COUNT && i < vecSelectedItems.Count(); ++i )
|
|
{
|
|
CEconItemView* pPrevItem = ( i - 1 ) < 0 ? NULL : vecSelectedItems[ i - 1 ];
|
|
bCanCraftUp &= GetCollectionCraftingInvalidReason( vecSelectedItems[ i ], pPrevItem ) == NULL;
|
|
}
|
|
|
|
bool bCanStatClockTrade = true;
|
|
for (int i = 0; i < COLLECTION_CRAFTING_ITEM_COUNT && i < vecSelectedItems.Count(); ++i)
|
|
{
|
|
CEconItemView* pPrevItem = (i - 1) < 0 ? NULL : vecSelectedItems[i - 1];
|
|
bCanStatClockTrade &= GetCraftCommonStatClockInvalidReason(vecSelectedItems[i], pPrevItem) == NULL;
|
|
}
|
|
|
|
Menu *pMannCoTradeSubMenu = NULL;
|
|
|
|
if ( bCanCraftUp || bCanStatClockTrade )
|
|
{
|
|
pMannCoTradeSubMenu = new Menu(this, "MannCoTradeSubMenu");
|
|
pMannCoTradeSubMenu->SetBorder(scheme()->GetIScheme(GetScheme())->GetBorder(pszContextMenuBorder));
|
|
pMannCoTradeSubMenu->SetFont(scheme()->GetIScheme(GetScheme())->GetFont(pszContextMenuFont));
|
|
contextMenuBuilder.AddCascadingMenuItem("#Context_MannCoTrade", pMannCoTradeSubMenu, "customization");
|
|
|
|
if (bCanCraftUp)
|
|
{
|
|
int nIndex = pMannCoTradeSubMenu->AddMenuItem("", new KeyValues("Command", "command", "Context_CraftUpCollection"), this);
|
|
vgui::MenuItem *pMenuItem = pMannCoTradeSubMenu->GetMenuItem(nIndex);
|
|
pMenuItem->SetText("#Context_TradeUp");
|
|
pMenuItem->InvalidateLayout(true, false);
|
|
}
|
|
|
|
if (bCanStatClockTrade)
|
|
{
|
|
int nIndex = pMannCoTradeSubMenu->AddMenuItem("", new KeyValues("Command", "command", "Context_CraftCommonStatClock"), this);
|
|
vgui::MenuItem *pMenuItem = pMannCoTradeSubMenu->GetMenuItem(nIndex);
|
|
pMenuItem->SetText("#Context_CommonStatClock");
|
|
pMenuItem->InvalidateLayout(true, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !m_bShowBaseItems )
|
|
{
|
|
bool bDeleteAvailable = true;
|
|
// Check that all of the selected items are deletable
|
|
for( int i=0; i < vecSelectedItems.Count() && bDeleteAvailable; ++i )
|
|
{
|
|
static CSchemaAttributeDefHandle pAttrDef_NoDelete( "cannot delete" );
|
|
bDeleteAvailable &= !vecSelectedItems[i]->FindAttribute( pAttrDef_NoDelete );
|
|
}
|
|
|
|
// Only show the delete button if every slected item is deletable
|
|
if ( bDeleteAvailable )
|
|
{
|
|
contextMenuBuilder.AddMenuItem( "#TF_SteamWorkshop_Delete", new KeyValues( "DoDelete" ), "destructive" );
|
|
}
|
|
}
|
|
|
|
// Position to the cursor's position
|
|
int nX, nY;
|
|
g_pVGuiInput->GetCursorPosition( nX, nY );
|
|
m_pContextMenu->SetPos( nX - 1, nY - 1 );
|
|
|
|
m_pContextMenu->SetVisible(true);
|
|
m_pContextMenu->AddActionSignalTarget(this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnItemPanelMouseRightRelease( vgui::Panel *panel )
|
|
{
|
|
#ifdef STAGING_ONLY
|
|
if ( tf_use_card_tooltips.GetBool() )
|
|
{
|
|
m_pMouseOverCardPanel->PinCard( true );
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
CItemModelPanel *pItemPanel = dynamic_cast < CItemModelPanel * > ( panel );
|
|
if ( pItemPanel && pItemPanel->IsVisible() )
|
|
{
|
|
// If they're not holding down ctrl, deselect all existing selections
|
|
if ( !vgui::input()->IsKeyDown(KEY_LCONTROL) && !vgui::input()->IsKeyDown(KEY_RCONTROL) )
|
|
{
|
|
DeSelectAllBackpackItemPanels();
|
|
ToggleSelectBackpackItemPanel( pItemPanel );
|
|
}
|
|
else if ( AllowSelection() && !pItemPanel->IsGreyedOut() )
|
|
{
|
|
if ( !pItemPanel->IsSelected() && pItemPanel->HasItem() )
|
|
{
|
|
pItemPanel->SetSelected( true );
|
|
}
|
|
SetBorderForItem( pItemPanel, false );
|
|
}
|
|
|
|
OpenContextMenu();
|
|
}
|
|
}
|
|
}
|
|
|
|
void CBackpackPanel::OnMouseMismatchedRelease( MouseCode code, Panel* pPressedPanel )
|
|
{
|
|
if ( pPressedPanel )
|
|
{
|
|
OnMouseReleased( code );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::StartDrag( int x, int y )
|
|
{
|
|
// don't allow item drag if there's a filter
|
|
if ( HasNameFilter() )
|
|
return;
|
|
|
|
m_bDragging = true;
|
|
HideMouseOverPanel();
|
|
|
|
vgui::ivgui()->AddTickSignal( GetVPanel() );
|
|
|
|
m_pMouseDragItemPanel->SetItem( m_pItemDraggedFromPanel->GetItem() );
|
|
m_pMouseDragItemPanel->InvalidateLayout( true );
|
|
|
|
m_pItemDraggedFromPanel->Dragged( true );
|
|
|
|
// Calculate the mouse offset from the top left of the panel we're going to drag
|
|
m_iDragOffsetX = m_pMouseDragItemPanel->GetWide() * 0.5f;
|
|
m_iDragOffsetY = m_pMouseDragItemPanel->GetTall() * 0.5f;
|
|
m_flPreventDragPageSwitchUntil = 0;
|
|
|
|
m_pMouseDragItemPanel->SetVisible( true );
|
|
|
|
m_pItemDraggedFromPanel->SetItem( NULL );
|
|
SetBorderForItem( m_pItemDraggedFromPanel, false );
|
|
m_pPrevDragOverItemPanel = NULL;
|
|
|
|
vgui::input()->SetMouseCapture( GetVPanel() );
|
|
|
|
if ( m_pDragToNextPageButton && m_pDragToPrevPageButton )
|
|
{
|
|
m_pDragToNextPageButton->SetVisible( GetNumPages() > 1 );
|
|
m_pDragToPrevPageButton->SetVisible( GetNumPages() > 1 );
|
|
}
|
|
|
|
// play pickup sound
|
|
CEconItemView *item = m_pMouseDragItemPanel->GetItem();
|
|
if ( item )
|
|
{
|
|
const char *soundFilename = item->GetDefinitionString( "pickup_sound", "" );
|
|
if ( soundFilename[0] )
|
|
{
|
|
vgui::surface()->PlaySound( soundFilename );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::StopDrag( bool bSucceeded )
|
|
{
|
|
if ( !m_pItemDraggedFromPanel )
|
|
return;
|
|
|
|
if ( !bSucceeded )
|
|
{
|
|
if ( m_iDraggedFromPage == GetCurrentPage() )
|
|
{
|
|
m_pItemDraggedFromPanel->SetItem( m_pMouseDragItemPanel->GetItem() );
|
|
}
|
|
m_pItemDraggedFromPanel = NULL;
|
|
}
|
|
|
|
m_pMouseDragItemPanel->SetVisible( false );
|
|
m_bDragging = false;
|
|
|
|
vgui::input()->SetMouseCapture( NULL );
|
|
|
|
if ( m_pDragToNextPageButton && m_pDragToPrevPageButton )
|
|
{
|
|
m_pDragToNextPageButton->SetVisible( false );
|
|
m_pDragToPrevPageButton->SetVisible( false );
|
|
}
|
|
|
|
// play drop sound
|
|
CEconItemView *item = m_pMouseDragItemPanel->GetItem();
|
|
if ( item )
|
|
{
|
|
const char *soundFilename = item->GetDefinitionString( "drop_sound", "ui/item_default_drop.wav" );
|
|
vgui::surface()->PlaySound( soundFilename );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CBackpackPanel::GetBackpackPositionForPanel( CItemModelPanel *pItemPanel )
|
|
{
|
|
for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
|
|
{
|
|
if ( m_pItemModelPanels[i] == pItemPanel )
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::HandleDragTo( CItemModelPanel *pItemPanel, int iPanelIndex )
|
|
{
|
|
// Find the position based on the panel we're dragging to
|
|
if ( iPanelIndex != -1 )
|
|
{
|
|
// If the current panel is selected, unselect it
|
|
if ( m_pItemModelPanels[iPanelIndex]->IsSelected() )
|
|
{
|
|
ToggleSelectBackpackItemPanel( m_pItemModelPanels[iPanelIndex] );
|
|
}
|
|
if ( m_pItemDraggedFromPanel->IsSelected() )
|
|
{
|
|
ToggleSelectBackpackItemPanel( m_pItemDraggedFromPanel );
|
|
}
|
|
|
|
// We "move" the items in the backpack immediately, because when the messages come back
|
|
// from steam they'll fix the positions if the move fails for some reason.
|
|
CEconItemView *pItem = NULL;
|
|
if ( m_pItemModelPanels[iPanelIndex]->HasItem() )
|
|
{
|
|
// We need to copy it because it's about to get stomped by the other item
|
|
pItem = new CEconItemView( *m_pItemModelPanels[iPanelIndex]->GetItem() );
|
|
}
|
|
m_pItemModelPanels[iPanelIndex]->SetItem( m_pMouseDragItemPanel->GetItem() );
|
|
|
|
if ( m_iDraggedFromPage == GetCurrentPage() )
|
|
{
|
|
m_pItemDraggedFromPanel->SetItem( pItem );
|
|
}
|
|
|
|
if ( pItem )
|
|
{
|
|
delete pItem;
|
|
}
|
|
|
|
// Tell the inventory to move the item
|
|
// Translate it to the right page
|
|
int iBackpackPosition = GetBackpackPosForPanelIndex( iPanelIndex );
|
|
InventoryManager()->MoveItemToBackpackPosition( m_pMouseDragItemPanel->GetItem(), iBackpackPosition );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnTick( void )
|
|
{
|
|
BaseClass::OnTick();
|
|
|
|
bool bNeedsTick = false;
|
|
if ( m_flStartExplanationsAt && m_flStartExplanationsAt < Plat_FloatTime() )
|
|
{
|
|
m_flStartExplanationsAt = 0;
|
|
|
|
if ( ShouldShowExplanations() )
|
|
{
|
|
ConVar *pConVar = GetExplanationConVar();
|
|
if ( pConVar )
|
|
{
|
|
pConVar->SetValue( 1 );
|
|
}
|
|
|
|
CExplanationPopup *pPopup = dynamic_cast<CExplanationPopup*>( FindChildByName("StartExplanation") );
|
|
if ( pPopup )
|
|
{
|
|
pPopup->Popup();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bNeedsTick = true;
|
|
}
|
|
|
|
// To handle page movement while holding the mouse still over the page buttons,
|
|
// we need to keep calling OnCursorMoved() whenever we're dragging.
|
|
if ( m_bDragging && m_pMouseDragItemPanel && m_pItemDraggedFromPanel && IsVisible() )
|
|
{
|
|
int mx,my;
|
|
vgui::input()->GetCursorPos( mx, my );
|
|
ScreenToLocal( mx, my );
|
|
OnCursorMoved( mx,my );
|
|
|
|
bNeedsTick = true;
|
|
}
|
|
|
|
if ( !bNeedsTick && !NeedsDerivedTickSignal() )
|
|
{
|
|
vgui::ivgui()->RemoveTickSignal( GetVPanel() );
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnThink( void )
|
|
{
|
|
BaseClass::OnThink();
|
|
|
|
if ( m_flFilterItemTime > 0 && gpGlobals->curtime >= m_flFilterItemTime )
|
|
{
|
|
SetCurrentPage( 0 );
|
|
DeSelectAllBackpackItemPanels();
|
|
UpdateModelPanels();
|
|
|
|
m_flFilterItemTime = 0.0f;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnCursorMoved( int x, int y )
|
|
{
|
|
if ( !m_pItemDraggedFromPanel )
|
|
return;
|
|
|
|
if ( m_bDragging && m_pMouseDragItemPanel )
|
|
{
|
|
m_pMouseDragItemPanel->SetPos( x - m_iDragOffsetX, y - m_iDragOffsetY );
|
|
|
|
// When we're dragging, we have mouse capture, so the item panels aren't getting mouse input.
|
|
// We need to find out what item panel we're over, and let it know.
|
|
|
|
if ( m_flPreventDragPageSwitchUntil < Plat_FloatTime() )
|
|
{
|
|
// First, are we over the page turning areas?
|
|
bool bDragNext = false;
|
|
if ( m_pDragToNextPageButton && m_pDragToNextPageButton->IsVisible() )
|
|
{
|
|
int iDragX, iDragY;
|
|
m_pDragToNextPageButton->GetPos( iDragX, iDragY );
|
|
bDragNext = ( x >= iDragX && x <= (iDragX + m_pDragToNextPageButton->GetWide() ) );
|
|
}
|
|
if ( !bDragNext && m_pNextPageButton && m_pNextPageButton->IsEnabled() )
|
|
{
|
|
int iDragX, iDragY;
|
|
m_pNextPageButton->GetPos( iDragX, iDragY );
|
|
bDragNext = ( x >= iDragX && x <= (iDragX + m_pNextPageButton->GetWide()) && y >= iDragY && y <= (iDragY + m_pNextPageButton->GetTall()) );
|
|
}
|
|
if ( bDragNext )
|
|
{
|
|
OnCommand( "nextpage" );
|
|
m_flPreventDragPageSwitchUntil = Plat_FloatTime() + tf_backpack_page_button_delay.GetFloat();
|
|
return;
|
|
}
|
|
|
|
bool bDragPrev = false;
|
|
if ( m_pDragToPrevPageButton && m_pDragToPrevPageButton->IsVisible() )
|
|
{
|
|
int iDragX, iDragY;
|
|
m_pDragToPrevPageButton->GetPos( iDragX, iDragY );
|
|
bDragPrev = ( x >= iDragX && x <= (iDragX + m_pDragToPrevPageButton->GetWide() ) );
|
|
}
|
|
if ( !bDragPrev && m_pPrevPageButton && m_pPrevPageButton->IsEnabled() )
|
|
{
|
|
int iDragX, iDragY;
|
|
m_pPrevPageButton->GetPos( iDragX, iDragY );
|
|
bDragPrev = ( x >= iDragX && x <= (iDragX + m_pPrevPageButton->GetWide()) && y >= iDragY && y <= (iDragY + m_pPrevPageButton->GetTall()) );
|
|
}
|
|
if ( bDragPrev )
|
|
{
|
|
OnCommand( "prevpage" );
|
|
m_flPreventDragPageSwitchUntil = Plat_FloatTime() + tf_backpack_page_button_delay.GetFloat();
|
|
return;
|
|
}
|
|
}
|
|
|
|
// check if we're hovering page button
|
|
static int iPrevHoveringPage = -1;
|
|
static float flLastPageButtonEnterTime = 0.f;
|
|
int iHoveringPage = GetPageButtonIndexAtPos( x, y );
|
|
if ( iHoveringPage != -1 )
|
|
{
|
|
if ( iHoveringPage == GetCurrentPage() )
|
|
{
|
|
iPrevHoveringPage = -1;
|
|
flLastPageButtonEnterTime = 0.f;
|
|
}
|
|
else if ( iPrevHoveringPage != iHoveringPage )
|
|
{
|
|
iPrevHoveringPage = iHoveringPage;
|
|
flLastPageButtonEnterTime = Plat_FloatTime() + tf_backpack_page_button_delay.GetFloat();
|
|
}
|
|
else if ( flLastPageButtonEnterTime > 0 && flLastPageButtonEnterTime < Plat_FloatTime() )
|
|
{
|
|
flLastPageButtonEnterTime = 0.f;
|
|
SetCurrentPage( iHoveringPage );
|
|
UpdateModelPanels();
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// reset hovering page buttons data
|
|
iPrevHoveringPage = -1;
|
|
flLastPageButtonEnterTime = 0.f;
|
|
}
|
|
|
|
CItemModelPanel *pOverPanel = GetItemPanelAtPos( x, y );
|
|
if ( m_pPrevDragOverItemPanel != pOverPanel )
|
|
{
|
|
if ( m_pPrevDragOverItemPanel )
|
|
{
|
|
OnItemPanelExited( m_pPrevDragOverItemPanel );
|
|
}
|
|
|
|
m_pPrevDragOverItemPanel = pOverPanel;
|
|
|
|
if ( m_pPrevDragOverItemPanel )
|
|
{
|
|
OnItemPanelEntered( m_pPrevDragOverItemPanel );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnItemPanelCursorMoved( int x, int y )
|
|
{
|
|
if ( !m_pItemDraggedFromPanel )
|
|
return;
|
|
|
|
if ( !m_bDragging && m_pItemDraggedFromPanel->HasItem() && !InToolSelectionMode() )
|
|
{
|
|
// Don't drag instantly, so it's easy to select
|
|
if ( (gpGlobals->curtime - m_flMouseDownTime) > 0.3 )
|
|
{
|
|
StartDrag( x,y );
|
|
}
|
|
else
|
|
{
|
|
if ( !m_iMouseDownX )
|
|
{
|
|
m_iMouseDownX = x;
|
|
m_iMouseDownY = y;
|
|
}
|
|
else if ( abs(m_iMouseDownX - x) > XRES(10) || abs(m_iMouseDownY - y) > YRES(10) )
|
|
{
|
|
StartDrag( x,y );
|
|
}
|
|
}
|
|
}
|
|
|
|
OnCursorMoved( x, y );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::ToggleSelectBackpackItemPanel( CItemModelPanel *pPanel )
|
|
{
|
|
if ( !AllowSelection() || pPanel->IsGreyedOut() )
|
|
return;
|
|
|
|
if ( pPanel->IsSelected() || !pPanel->HasItem() )
|
|
{
|
|
pPanel->SetSelected( false );
|
|
}
|
|
else
|
|
{
|
|
pPanel->SetSelected( true );
|
|
}
|
|
SetBorderForItem( pPanel, false );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DeSelectAllBackpackItemPanels( void )
|
|
{
|
|
for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
|
|
{
|
|
if ( m_pItemModelPanels[i]->IsSelected() )
|
|
{
|
|
m_pItemModelPanels[i]->SetSelected( false );
|
|
SetBorderForItem( m_pItemModelPanels[i], false );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called whenever the selection changes in the item loadout panel
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnItemContentsChanged( CEconItemView *pEconItemView )
|
|
{
|
|
Assert( pEconItemView );
|
|
|
|
for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
|
|
{
|
|
CEconItemView *pInternalItem = m_pItemModelPanels[i] && m_pItemModelPanels[i]->HasItem()
|
|
? m_pItemModelPanels[i]->GetItem()
|
|
: NULL;
|
|
|
|
if ( *pInternalItem == *pEconItemView )
|
|
{
|
|
m_pItemModelPanels[i]->DirtyDescription();
|
|
OnItemSelectionChanged();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Called when text changes in combo box
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnTextChanged( KeyValues *data )
|
|
{
|
|
Panel *pPanel = reinterpret_cast<vgui::Panel *>( data->GetPtr("panel") );
|
|
|
|
vgui::TextEntry *pTextEntry = dynamic_cast<vgui::TextEntry *>( pPanel );
|
|
if ( pTextEntry )
|
|
{
|
|
if ( pTextEntry == m_pNameFilterTextEntry )
|
|
{
|
|
m_wNameFilter.RemoveAll();
|
|
if ( m_pNameFilterTextEntry->GetTextLength() )
|
|
{
|
|
m_wNameFilter.EnsureCount( m_pNameFilterTextEntry->GetTextLength() + 1 );
|
|
m_pNameFilterTextEntry->GetText( m_wNameFilter.Base(), m_wNameFilter.Count() * sizeof(wchar_t) );
|
|
V_wcslower( m_wNameFilter.Base() );
|
|
}
|
|
m_flFilterItemTime = gpGlobals->curtime + 0.5f;
|
|
return;
|
|
}
|
|
}
|
|
|
|
vgui::ComboBox *pComboBox = dynamic_cast<vgui::ComboBox *>( pPanel );
|
|
if ( pComboBox )
|
|
{
|
|
if ( pComboBox == m_pSortByComboBox )
|
|
{
|
|
// the class selection combo box changed, update class details
|
|
KeyValues *pUserData = m_pSortByComboBox->GetActiveItemUserData();
|
|
if ( !pUserData )
|
|
return;
|
|
|
|
enum { kSortType_Dummy = -1 };
|
|
int iSortTypeSelectionIndex = pUserData->GetInt( "sortby", kSortType_Dummy );
|
|
if ( iSortTypeSelectionIndex != kSortType_Dummy )
|
|
{
|
|
uint32 iSortType = g_BackpackSortTypes[iSortTypeSelectionIndex].iSortType;
|
|
if ( iSortType != kGCItemSort_NoSort )
|
|
{
|
|
InventoryManager()->SortBackpackBy( iSortType );
|
|
|
|
// Now go back to the "Sort by" header, and move the focus to the close button.
|
|
m_pSortByComboBox->ActivateItemByRow( 0 );
|
|
}
|
|
}
|
|
}
|
|
else if ( pComboBox == m_pShowRarityComboBox )
|
|
{
|
|
cl_showbackpackrarities.SetValue( m_pShowRarityComboBox->GetActiveItem() );
|
|
|
|
// Refresh all item borders
|
|
for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
|
|
{
|
|
SetBorderForItem( m_pItemModelPanels[i], false );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnButtonChecked( KeyValues *pData )
|
|
{
|
|
Panel *pPanel = reinterpret_cast<vgui::Panel *>( pData->GetPtr("panel") );
|
|
|
|
if ( m_bShowBaseItems != m_pShowBaseItemsCheckbox->IsSelected() && m_pShowBaseItemsCheckbox == pPanel && IsVisible() )
|
|
{
|
|
SetShowBaseItems( m_pShowBaseItemsCheckbox->IsSelected() );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnCancelSelection( void )
|
|
{
|
|
if ( m_pConfirmDeleteDialog )
|
|
{
|
|
m_pConfirmDeleteDialog->MarkForDeletion();
|
|
m_pConfirmDeleteDialog = NULL;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const char *CBackpackPanel::GetGreyOutItemPanelReason( CItemModelPanel *pItemPanel )
|
|
{
|
|
if ( InToolSelectionMode() )
|
|
{
|
|
bool bIsSelectedTool = (m_ToolSelectionItem.IsValid() && pItemPanel->HasItem()) ? (m_ToolSelectionItem == *pItemPanel->GetItem()) : false;
|
|
if ( !bIsSelectedTool )
|
|
{
|
|
if ( m_ToolSelectionItem.GetStaticData()->IsTool() )
|
|
{
|
|
if ( !CEconSharedToolSupport::ToolCanApplyTo( &m_ToolSelectionItem, pItemPanel->GetItem() ) )
|
|
{
|
|
return "#Econ_GreyOutReason_ToolCannotApply";
|
|
}
|
|
}
|
|
else if ( pItemPanel->GetItem() && pItemPanel->GetItem()->GetStaticData()->IsTool() )
|
|
{
|
|
if ( !CEconSharedToolSupport::ToolCanApplyTo( pItemPanel->GetItem(), &m_ToolSelectionItem ) )
|
|
{
|
|
return "#Econ_GreyOutReason_ToolCannotApply";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::SetBorderForItem( CItemModelPanel *pItemPanel, bool bMouseOver )
|
|
{
|
|
tmZone( TELEMETRY_LEVEL1, TMZF_NONE, "%s", __FUNCTION__ );
|
|
|
|
if ( !pItemPanel )
|
|
return;
|
|
|
|
const char *pszBorder = NULL;
|
|
|
|
bool bIsSelectedTool = (m_ToolSelectionItem.IsValid() && pItemPanel->HasItem()) ? (m_ToolSelectionItem == *pItemPanel->GetItem()) : false;
|
|
|
|
// Handle grey out
|
|
const char *pszGreyOutReason = GetGreyOutItemPanelReason( pItemPanel );
|
|
const bool bGreyOut = pszGreyOutReason != NULL;
|
|
|
|
pItemPanel->SetGreyedOut( pszGreyOutReason );
|
|
|
|
int iRarity = GetItemQualityForBorder( pItemPanel );
|
|
|
|
if ( InToolSelectionMode() && bIsSelectedTool )
|
|
{
|
|
// We're in tool application mode, and this panel is the tool being used
|
|
pszBorder = "BackpackItemBorder_SelfMade";
|
|
|
|
if ( m_pToolIcon )
|
|
{
|
|
int iX, iY;
|
|
pItemPanel->GetPos( iX, iY );
|
|
m_pToolIcon->SetPos( iX, iY );
|
|
m_pToolIcon->SetVisible( true );
|
|
}
|
|
}
|
|
else if ( bGreyOut )
|
|
{
|
|
if( pItemPanel->IsSelected() )
|
|
{
|
|
pszBorder = g_szItemBorders[iRarity][4];
|
|
}
|
|
else
|
|
{
|
|
pszBorder = g_szItemBorders[iRarity][3];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
if ( pItemPanel->IsSelected() )
|
|
{
|
|
pszBorder = g_szItemBorders[iRarity][2];
|
|
}
|
|
else if ( bMouseOver )
|
|
{
|
|
pszBorder = g_szItemBorders[iRarity][1];
|
|
}
|
|
else
|
|
{
|
|
pszBorder = g_szItemBorders[iRarity][0];
|
|
}
|
|
}
|
|
|
|
vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( GetScheme() );
|
|
pItemPanel->SetBorder( pScheme->GetBorder( pszBorder ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
class CTFRemoveItemCustomizationConfirmDialog : public CTFGenericConfirmDialog
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CTFRemoveItemCustomizationConfirmDialog, CTFGenericConfirmDialog );
|
|
public:
|
|
CTFRemoveItemCustomizationConfirmDialog( const RefurbishableProperty& prop, CEconItemView *pItem )
|
|
: CTFGenericConfirmDialog( prop.m_szDialogTitle, // dialog title
|
|
prop.m_szDialogDesc, // dialog text
|
|
"#RefurbishItem_Yes", // confirm button text
|
|
"#RefurbishItem_No", // cancel button text
|
|
NULL, // callback
|
|
NULL ) // parent
|
|
, m_prop( prop )
|
|
, m_Item( *pItem ) // copy in case our UI changes behind us
|
|
{
|
|
GetCustomDialogLocalizationTokenFunc_t m_pDialogCustomTokenFunc = m_prop.m_pGetCustomDialogLocalizationTokenFunc;
|
|
if ( m_pDialogCustomTokenFunc )
|
|
{
|
|
CUtlConstWideString wsDialogCustomToken;
|
|
(*m_pDialogCustomTokenFunc)( &m_Item, m_prop.m_iUserData, wsDialogCustomToken );
|
|
if ( !wsDialogCustomToken.IsEmpty() )
|
|
{
|
|
AddStringToken( "confirm_dialog_token", wsDialogCustomToken.Get() );
|
|
}
|
|
}
|
|
}
|
|
|
|
virtual ~CTFRemoveItemCustomizationConfirmDialog() { }
|
|
|
|
virtual void OnCommand( const char *command );
|
|
|
|
private:
|
|
RefurbishableProperty m_prop;
|
|
CEconItemView m_Item;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void SendGCSimpleAttributeRemovalMessage( CEconItemView *pEconItemView, const char *szDesc, EGCItemMsg eItemMsg )
|
|
{
|
|
EconUI()->Gamestats_ItemTransaction( IE_ITEM_REMOVED_ATTRIB, pEconItemView, szDesc );
|
|
GCSDK::CProtoBufMsg<CMsgGCRemoveCustomizationAttributeSimple> msg( eItemMsg );
|
|
msg.Body().set_item_id( pEconItemView->GetItemID() );
|
|
GCClientSystem()->BSendMessage( msg );
|
|
}
|
|
|
|
void CTFRemoveItemCustomizationConfirmDialog::OnCommand( const char *command )
|
|
{
|
|
BaseClass::OnCommand( command );
|
|
|
|
// Did the user say "yes, remove this particular attribute"? If so, notify the GC. We can't
|
|
// remove multiple attributes at a time because each removal will cause a new item to be created,
|
|
// invalidating the item reference we've got in this dialog.
|
|
if ( !Q_strnicmp( command, "confirm", 7 ) )
|
|
{
|
|
// remove the attribute
|
|
switch( m_prop.m_eRemovalType )
|
|
{
|
|
case kCustomizationRemove_Paint:
|
|
SendGCSimpleAttributeRemovalMessage( &m_Item, "paint", k_EMsgGCRemoveItemPaint );
|
|
break;
|
|
|
|
case kCustomizationRemove_Name:
|
|
{
|
|
EconUI()->Gamestats_ItemTransaction( IE_ITEM_REMOVED_ATTRIB, &m_Item, "name" );
|
|
GCSDK::CGCMsg< MsgGCRemoveItemName_t > msg( k_EMsgGCRemoveItemName );
|
|
msg.Body().m_unItemID = m_Item.GetItemID();
|
|
msg.Body().m_bDescription = false;
|
|
GCClientSystem()->BSendMessage( msg );
|
|
}
|
|
break;
|
|
|
|
case kCustomizationRemove_Desc:
|
|
{
|
|
EconUI()->Gamestats_ItemTransaction( IE_ITEM_REMOVED_ATTRIB, &m_Item, "description" );
|
|
GCSDK::CGCMsg< MsgGCRemoveItemName_t > msg( k_EMsgGCRemoveItemName );
|
|
msg.Body().m_unItemID = m_Item.GetItemID();
|
|
msg.Body().m_bDescription = true;
|
|
GCClientSystem()->BSendMessage( msg );
|
|
}
|
|
break;
|
|
|
|
case kCustomizationRemove_CustomTexture:
|
|
SendGCSimpleAttributeRemovalMessage( &m_Item, "custom_texture", k_EMsgGCRemoveCustomTexture );
|
|
break;
|
|
|
|
case kCustomizationRemove_MakersMark:
|
|
SendGCSimpleAttributeRemovalMessage( &m_Item, "makers_mark", k_EMsgGCRemoveMakersMark );
|
|
break;
|
|
|
|
case kCustomizationRemove_StrangePart:
|
|
{
|
|
Assert( m_prop.m_iUserData != kNoUserData );
|
|
int iKillEaterAttrIndex = m_prop.m_iUserData;
|
|
|
|
// What attribute did we select?
|
|
const CEconItemAttributeDefinition *pAttrDef = GetKillEaterAttr_Type( iKillEaterAttrIndex );
|
|
Assert( pAttrDef );
|
|
|
|
// Make sure this item has this attribute.
|
|
float fScoreType = kKillEaterEvent_PlayerKill;
|
|
Verify( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( &m_Item, pAttrDef, &fScoreType ) || iKillEaterAttrIndex == 0 );
|
|
|
|
// Dispatch message.
|
|
EconUI()->Gamestats_ItemTransaction( IE_ITEM_REMOVED_ATTRIB, &m_Item, "strange_part" );
|
|
GCSDK::CProtoBufMsg<CMsgGCRemoveStrangePart> msg( k_EMsgGCRemoveStrangePart );
|
|
|
|
msg.Body().set_item_id( m_Item.GetItemID() );
|
|
msg.Body().set_strange_part_score_type( (int)fScoreType );
|
|
GCClientSystem()->BSendMessage( msg );
|
|
}
|
|
break;
|
|
|
|
case kCustomizationRemove_StrangeScores:
|
|
{
|
|
Assert( m_prop.m_iUserData == kNoUserData );
|
|
|
|
EconUI()->Gamestats_ItemTransaction( IE_ITEM_RESET_STRANGE_COUNTERS, &m_Item );
|
|
GCSDK::CProtoBufMsg<CMsgGCResetStrangeScores> msg( k_EMsgGCResetStrangeScores );
|
|
msg.Body().set_item_id( m_Item.GetItemID() );
|
|
GCClientSystem()->BSendMessage( msg );
|
|
}
|
|
break;
|
|
|
|
case kCustomizationRemove_UpgradeCard:
|
|
{
|
|
Assert( m_prop.m_iUserData != kNoUserData );
|
|
|
|
// Make sure we selected a valid attribute that this item has.
|
|
const CEconItemAttributeDefinition *pAttrDef = GetCardUpgradeForIndex( &m_Item, m_prop.m_iUserData );
|
|
Assert( pAttrDef );
|
|
Verify( m_Item.FindAttribute( pAttrDef ) );
|
|
|
|
// Dispatch message.
|
|
EconUI()->Gamestats_ItemTransaction( IE_ITEM_REMOVED_ATTRIB, &m_Item, "upgrade_card" );
|
|
GCSDK::CProtoBufMsg<CMsgGCRemoveUpgradeCard> msg( k_EMsgGCRemoveUpgradeCard );
|
|
|
|
msg.Body().set_item_id( m_Item.GetItemID() );
|
|
msg.Body().set_attribute_index( pAttrDef->GetDefinitionIndex() );
|
|
GCClientSystem()->BSendMessage( msg );
|
|
}
|
|
break;
|
|
|
|
case kCustomizationRemove_KillStreak:
|
|
SendGCSimpleAttributeRemovalMessage( &m_Item, "killstreak", k_EMsgGCRemoveKillStreak );
|
|
break;
|
|
case kCustomizationRemove_GiftedBy:
|
|
SendGCSimpleAttributeRemovalMessage( &m_Item, "giftedby", k_EMsgGCRemoveGiftedBy );
|
|
break;
|
|
case kCustomizationRemove_Festivizer:
|
|
SendGCSimpleAttributeRemovalMessage( &m_Item, "festivizer", k_EMsgGCRemoveFestivizer );
|
|
break;
|
|
default:
|
|
AssertMsg( false, "Unknown item customization removal type!" );
|
|
break;
|
|
}
|
|
}
|
|
|
|
SetVisible( false );
|
|
MarkForDeletion();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
class CRefurbishItemDialog : public CComboBoxBackpackOverlayDialogBase
|
|
{
|
|
public:
|
|
DECLARE_CLASS_SIMPLE( CRefurbishItemDialog, CComboBoxBackpackOverlayDialogBase );
|
|
|
|
public:
|
|
CRefurbishItemDialog( vgui::Panel *pParent, CEconItemView *m_pItem ) : CComboBoxBackpackOverlayDialogBase( pParent, m_pItem ) { }
|
|
|
|
private:
|
|
virtual void PopulateComboBoxOptions()
|
|
{
|
|
Assert( m_pItem );
|
|
|
|
KeyValues *pKeyValues = new KeyValues( "data" );
|
|
for ( int i = 0; i < GetRemovableAttributesCount(); i++ )
|
|
{
|
|
if ( RemovableAttributes_DoesAttributeApply( i, m_pItem ) )
|
|
{
|
|
pKeyValues->SetInt( "data", i );
|
|
|
|
RefurbishableProperty prop = RemovableAttributes_GetAttributeDetails( i );
|
|
|
|
CUtlConstWideString wsDialogCustomToken;
|
|
if ( prop.m_pGetCustomDialogLocalizationTokenFunc )
|
|
{
|
|
(*prop.m_pGetCustomDialogLocalizationTokenFunc)( m_pItem, prop.m_iUserData, wsDialogCustomToken );
|
|
}
|
|
CConstructLocalizedString localizedUI( GLocalizationProvider()->Find( prop.m_pszSelectionUILocalizationToken ), wsDialogCustomToken.IsEmpty() ? L"" : wsDialogCustomToken.Get() );
|
|
GetComboBox()->AddItem( localizedUI, pKeyValues );
|
|
}
|
|
}
|
|
pKeyValues->deleteThis();
|
|
|
|
Assert( GetComboBox()->GetItemCount() > 0 );
|
|
|
|
GetComboBox()->ActivateItemByRow( 0 );
|
|
}
|
|
|
|
virtual void OnComboBoxApplication()
|
|
{
|
|
if ( !m_pItem )
|
|
return;
|
|
|
|
KeyValues *pKVActiveUserData = GetComboBox()->GetActiveItemUserData();
|
|
int iIndex = pKVActiveUserData ? pKVActiveUserData->GetInt( "data", -1 ) : -1;
|
|
if ( iIndex < 0 )
|
|
return;
|
|
|
|
const RefurbishableProperty RefurbProp = RemovableAttributes_GetAttributeDetails( iIndex );
|
|
|
|
CTFRemoveItemCustomizationConfirmDialog *pDialog = new CTFRemoveItemCustomizationConfirmDialog( RefurbProp, m_pItem );
|
|
if ( pDialog )
|
|
{
|
|
pDialog->Show();
|
|
}
|
|
}
|
|
|
|
virtual const char *GetTitleLabelLocalizationToken() const { return "#TF_Item_RefurbishItemHeader"; }
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handles item selection while in tool selection mode
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::HandleToolItemSelection( CEconItemView *pItem )
|
|
{
|
|
if ( !InToolSelectionMode() )
|
|
{
|
|
// must be in tool selection mode
|
|
Assert( InToolSelectionMode() );
|
|
return;
|
|
}
|
|
|
|
if ( pItem )
|
|
{
|
|
// Check if we should bring up the shuffle dialog instead of directly using the tool
|
|
static CSchemaAttributeDefHandle pAttrDef_CanShuffleCrateContents( "can shuffle crate contents" );
|
|
if ( pItem->FindAttribute( pAttrDef_CanShuffleCrateContents ) )
|
|
{
|
|
CInputStringForItemBackpackOverlayDialog *pDialog = vgui::SETUP_PANEL( new CInputStringForItemBackpackOverlayDialog( this, pItem, &m_ToolSelectionItem ) );
|
|
if ( pDialog )
|
|
{
|
|
pDialog->Show();
|
|
CancelToolSelection();
|
|
}
|
|
}
|
|
else if ( m_ToolSelectionItem.FindAttribute( pAttrDef_CanShuffleCrateContents ) )
|
|
{
|
|
CInputStringForItemBackpackOverlayDialog *pDialog = vgui::SETUP_PANEL( new CInputStringForItemBackpackOverlayDialog( this, &m_ToolSelectionItem, pItem ) );
|
|
if ( pDialog )
|
|
{
|
|
pDialog->Show();
|
|
CancelToolSelection();
|
|
}
|
|
}
|
|
// is a tool being applied onto this item
|
|
else if ( m_ToolSelectionItem.GetStaticData()->IsTool() && ApplyTool( this, &m_ToolSelectionItem, pItem ) )
|
|
{
|
|
CancelToolSelection();
|
|
UpdateModelPanels();
|
|
}
|
|
// is this item a tool that can be applied on a selected item
|
|
else if ( pItem->GetStaticData()->IsTool() && ApplyTool( this, pItem, &m_ToolSelectionItem ) )
|
|
{
|
|
CancelToolSelection();
|
|
UpdateModelPanels();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Tries to use the item. This might switch the panel to a tool item
|
|
// selection mode, or launch the recipe crafting panel.
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::SetupToolSelectionItem()
|
|
{
|
|
for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
|
|
{
|
|
if ( m_pItemModelPanels[i]->IsSelected() && m_pItemModelPanels[i]->HasItem() )
|
|
{
|
|
m_ToolSelectionItem = *m_pItemModelPanels[i]->GetItem();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Open up the trade dialog
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoTradeToPlayer()
|
|
{
|
|
OpenTradingStartDialog( this );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Use the trade dialog to send a gift to a player.
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoGiftToPlayer()
|
|
{
|
|
OpenTradingStartDialog( this, &m_ToolSelectionItem );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Open up the overlay to sell the selected item
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoSellMarketplace()
|
|
{
|
|
CUtlVector< CItemModelPanel* > m_vecSelected;
|
|
GetSelectedPanels( SELECT_FIRST, m_vecSelected );
|
|
Assert( m_vecSelected.Count() );
|
|
if( !m_vecSelected.Count() )
|
|
return;
|
|
|
|
if ( m_vecSelected.Count() && steamapicontext && steamapicontext->SteamFriends() && steamapicontext->SteamUtils() )
|
|
{
|
|
CEconItemView *pItem = m_vecSelected.Head()->GetItem();
|
|
const char *pszPrefix = "";
|
|
if ( GetUniverse() == k_EUniverseBeta )
|
|
{
|
|
pszPrefix = "beta.";
|
|
}
|
|
uint32 nAssetContext = 2; // k_EEconContextBackpack
|
|
char szURL[512];
|
|
V_snprintf( szURL, sizeof(szURL), "http://%ssteamcommunity.com/my/inventory/?sellOnLoad=1#%d_%d_%llu", pszPrefix, engine->GetAppID(), nAssetContext, pItem->GetItemID() );
|
|
steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( szURL );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Use a description tag, or offer to buy one
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoDescription()
|
|
{
|
|
static CSchemaItemDefHandle pItemDef_DescTag( "Description Tag" );
|
|
if ( !AttemptToUseItem( pItemDef_DescTag->GetDefinitionIndex() ) )
|
|
{
|
|
AttemptToShowItemInStore( pItemDef_DescTag->GetDefinitionIndex() );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Use a name tag, or offer to buy one
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoRename()
|
|
{
|
|
static CSchemaItemDefHandle pItemDef_NameTag( "Name Tag" );
|
|
if ( !AttemptToUseItem( pItemDef_NameTag->GetDefinitionIndex() ) )
|
|
{
|
|
AttemptToShowItemInStore( pItemDef_NameTag->GetDefinitionIndex() );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Delete the selected items
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoDelete()
|
|
{
|
|
// Hide the mouseover panel
|
|
HideMouseOverPanel();
|
|
|
|
int iItemsToDelete = 0;
|
|
for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
|
|
{
|
|
if ( m_pItemModelPanels[i]->IsSelected() && m_pItemModelPanels[i]->HasItem() )
|
|
{
|
|
iItemsToDelete++;
|
|
}
|
|
}
|
|
|
|
// Bring up confirm dialog
|
|
CConfirmDeleteItemDialog *pConfirm = vgui::SETUP_PANEL( new CConfirmDeleteItemDialog( this, ( iItemsToDelete > 1 ) ) );
|
|
if ( pConfirm )
|
|
{
|
|
pConfirm->Show();
|
|
|
|
m_pConfirmDeleteDialog = pConfirm;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Use the selected tool
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoApplyOnItem()
|
|
{
|
|
SetupToolSelectionItem();
|
|
|
|
if ( m_ToolSelectionItem.IsValid() )
|
|
{
|
|
const IEconTool *pEconTool = m_ToolSelectionItem.GetItemDefinition()->GetEconTool();
|
|
|
|
// Gather all quest objective attributes
|
|
CRecipeComponentMatchingIterator recipeIterator( NULL, NULL );
|
|
if ( m_ToolSelectionItem.GetSOCData() )
|
|
{
|
|
m_ToolSelectionItem.GetSOCData()->IterateAttributes( &recipeIterator );
|
|
}
|
|
|
|
if( pEconTool && recipeIterator.GetMatchingComponentInputs().Count() > 0 )
|
|
{
|
|
// Launch new crafting window if we need to
|
|
if( m_pDynamicRecipePanel == NULL )
|
|
{
|
|
m_pDynamicRecipePanel = vgui::SETUP_PANEL( new CDynamicRecipePanel( this, "dynamic_recipe_panel", &m_ToolSelectionItem ) );
|
|
}
|
|
|
|
// Set recipe item into panel
|
|
if ( m_pDynamicRecipePanel )
|
|
{
|
|
m_pDynamicRecipePanel->SetVisible( true );
|
|
m_pDynamicRecipePanel->SetNewRecipe( &m_ToolSelectionItem );
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Check if we actually have any items we can use this tool on
|
|
bool bHasValidTargetItem = false;
|
|
CPlayerInventory *pInv = InventoryManager()->GetLocalInventory();
|
|
Assert( pInv );
|
|
if ( pInv )
|
|
{
|
|
for ( int i = 0 ; i < pInv->GetItemCount() ; ++i )
|
|
{
|
|
CEconItemView *pItem = pInv->GetItem( i );
|
|
if ( CEconSharedToolSupport::ToolCanApplyTo( &m_ToolSelectionItem, pItem ) )
|
|
{
|
|
bHasValidTargetItem = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If no applicable items, try stock items
|
|
if ( !bHasValidTargetItem )
|
|
{
|
|
// this is really inefficient, maybe have a list of baseitems somewhere
|
|
CEconItemView tempItem;
|
|
const CEconItemDefinition* pItemDef = NULL;
|
|
|
|
const CEconItemSchema::SortedItemDefinitionMap_t& mapItems = GetItemSchema()->GetSortedItemDefinitionMap();
|
|
for ( int it = mapItems.FirstInorder(); it != mapItems.InvalidIndex(); it = mapItems.NextInorder( it ) )
|
|
{
|
|
if ( mapItems[it]->IsBaseItem() && !mapItems[it]->IsHidden() )
|
|
{
|
|
CFmtStr fmtStrCustomizedDefName( "Upgradeable %s", mapItems[it]->GetDefinitionName() );
|
|
pItemDef = GetItemSchema()->GetItemDefinitionByName( fmtStrCustomizedDefName.Access() );
|
|
if ( pItemDef )
|
|
{
|
|
tempItem.Init( pItemDef->GetDefinitionIndex(), AE_UNIQUE, AE_USE_SCRIPT_VALUE, true );
|
|
if ( CEconSharedToolSupport::ToolCanApplyTo( &m_ToolSelectionItem, &tempItem ) )
|
|
{
|
|
bHasValidTargetItem = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bHasValidTargetItem )
|
|
{
|
|
// automatically switch to stock items
|
|
OnCommand( "showbaseitems" );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !bHasValidTargetItem )
|
|
{
|
|
ShowMessageBox( NULL, "#ToolNoTargetItems", "#GameUI_OK" );
|
|
return;
|
|
}
|
|
|
|
m_eSelectionMode = ToolSelection;
|
|
m_nLastToolPage = GetCurrentPage();
|
|
|
|
if ( m_pMouseOverTooltip )
|
|
{
|
|
m_pMouseOverTooltip->HideTooltip();
|
|
}
|
|
|
|
ClearNameFilter( true );
|
|
SetCurrentPage( 0 );
|
|
UpdateModelPanels();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: use a consumable item directly from the backpack
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoUseConsumableItem()
|
|
{
|
|
SetupToolSelectionItem();
|
|
|
|
#ifdef TF_CLIENT_DLL
|
|
UseConsumableItem( &m_ToolSelectionItem, this );
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Use the tool to unwrap an item
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoUnwrapItem()
|
|
{
|
|
DoUseConsumableItem();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Use the tool to deliver an item
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoDeliverItem()
|
|
{
|
|
SetupToolSelectionItem();
|
|
|
|
#ifdef TF_CLIENT_DLL
|
|
const CEconTool_WrappedGift *pWrappedGiftTool = m_ToolSelectionItem.GetItemDefinition()
|
|
? m_ToolSelectionItem.GetItemDefinition()->GetTypedEconTool<CEconTool_WrappedGift>()
|
|
: NULL;
|
|
|
|
if ( pWrappedGiftTool && pWrappedGiftTool->BIsDirectGift() )
|
|
{
|
|
DoUseConsumableItem();
|
|
return;
|
|
}
|
|
else if ( pWrappedGiftTool && pWrappedGiftTool->BIsGlobalGift() )
|
|
{
|
|
// If this is a global gift, we don't let the user pick a target so we're done as of now.
|
|
extern void UseUntargetedGiftConfirm( bool bConfirmed, void *pContext );
|
|
CTFGenericConfirmDialog *pDialog = ShowConfirmDialog( "#TF_DeliverGiftDialog_Title", "#TF_DeliverGiftDialog_Random_Text",
|
|
"#TF_DeliverGiftDialog_Confirm", "#TF_DeliverGiftDialog_Cancel",
|
|
&UseUntargetedGiftConfirm );
|
|
|
|
pDialog->SetContext( &m_ToolSelectionItem );
|
|
return;
|
|
}
|
|
|
|
DoGiftToPlayer();
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Show
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoApplyByItem()
|
|
{
|
|
SetupToolSelectionItem();
|
|
|
|
m_eSelectionMode = ToolSelection;
|
|
m_nLastToolPage = GetCurrentPage();
|
|
|
|
if ( m_pMouseOverTooltip )
|
|
{
|
|
m_pMouseOverTooltip->HideTooltip();
|
|
}
|
|
|
|
ClearNameFilter( true );
|
|
SetCurrentPage( 0 );
|
|
UpdateModelPanels();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: open shuffle items dialog
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoShuffle()
|
|
{
|
|
SetupToolSelectionItem();
|
|
|
|
CInputStringForItemBackpackOverlayDialog *pDialog = vgui::SETUP_PANEL( new CInputStringForItemBackpackOverlayDialog( this, &m_ToolSelectionItem ) );
|
|
if ( pDialog )
|
|
{
|
|
pDialog->Show();
|
|
}
|
|
}
|
|
|
|
void CBackpackPanel::DoEditSlot()
|
|
{
|
|
SetupToolSelectionItem();
|
|
|
|
// Launch new slot window if we need to
|
|
if( m_pItemSlotPanel == NULL )
|
|
{
|
|
m_pItemSlotPanel = vgui::SETUP_PANEL( new CItemSlotPanel( this ) );
|
|
}
|
|
|
|
// Set item into panel
|
|
if ( m_pItemSlotPanel )
|
|
{
|
|
m_pItemSlotPanel->SetVisible( true );
|
|
m_pItemSlotPanel->SetItem( m_ToolSelectionItem.GetSOCData() );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Refurbish item
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoRefurbishItem()
|
|
{
|
|
for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
|
|
{
|
|
if ( m_pItemModelPanels[i]->IsSelected() && m_pItemModelPanels[i]->HasItem() )
|
|
{
|
|
m_ComboBoxOverlaySelectionItem = *m_pItemModelPanels[i]->GetItem();
|
|
break;
|
|
}
|
|
}
|
|
|
|
CRefurbishItemDialog *pRefurbishDialog = vgui::SETUP_PANEL( new CRefurbishItemDialog( this, &m_ComboBoxOverlaySelectionItem ) );
|
|
if ( pRefurbishDialog )
|
|
{
|
|
pRefurbishDialog->Show();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Deode by item
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoGetItemFromStore()
|
|
{
|
|
SetupToolSelectionItem();
|
|
|
|
uint32 iDecoableItemDef = 0;
|
|
if ( GetDecodedByItemDefIndex( &m_ToolSelectionItem, &iDecoableItemDef ) )
|
|
{
|
|
// casting to the proper type since our econ system is dumb
|
|
const float& value_as_float = (float&)iDecoableItemDef;
|
|
CEconItemDefinition * pDefIndex = GetItemSchema()->GetItemDefinition( (int)value_as_float );
|
|
|
|
EconUI()->GetStorePanel()->AddToCartAndCheckoutImmediately( pDefIndex->GetDefinitionIndex() );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Open End of the Line duck leaderboards
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoOpenDuckLeaderboards()
|
|
{
|
|
CCharacterInfoPanel* pCharInfo = dynamic_cast< CCharacterInfoPanel* >( EconUI() );
|
|
CDucksLeaderboardManager *pDuckLeaderboards = vgui::SETUP_PANEL( new CDucksLeaderboardManager( pCharInfo, "DucksLeaderboardPanel" ) );
|
|
pDuckLeaderboards->SetVisible( true );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Strange Count Transfer Dialog
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoStrangeCountTransfer()
|
|
{
|
|
CUtlVector< CItemModelPanel* > vecSelected;
|
|
GetSelectedPanels( SELECT_FIRST, vecSelected );
|
|
|
|
Assert( vecSelected.Count() );
|
|
if ( vecSelected.IsEmpty() )
|
|
return;
|
|
|
|
m_pStrangeToolPanel = vgui::SETUP_PANEL( new CStrangeCountTransferPanel( this, vecSelected[0]->GetItem() ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Collection crafting
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoCraftUpCollection()
|
|
{
|
|
CUtlVector< CItemModelPanel* > vecSelected;
|
|
GetSelectedPanels( SELECT_ALL, vecSelected );
|
|
|
|
//Assert( vecSelected.Count() );
|
|
//if ( vecSelected.IsEmpty() )
|
|
// return;
|
|
|
|
// Get all the items that were selected
|
|
CUtlVector< const CEconItemView* > vecSelectedItems;
|
|
FOR_EACH_VEC( vecSelected, i )
|
|
{
|
|
if ( vecSelected[ i ]->GetItem() && GetCollectionCraftingInvalidReason( vecSelected[ i ]->GetItem(), NULL ) == NULL )
|
|
{
|
|
vecSelectedItems.AddToTail( vecSelected[ i ]->GetItem() );
|
|
}
|
|
}
|
|
|
|
// For tracking how many times they've opened this menu
|
|
tf_trade_up_use_count.SetValue( tf_trade_up_use_count.GetInt() - 1 );
|
|
|
|
// Open it up!
|
|
GetCollectionCraftPanel()->Show( vecSelectedItems );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Collection crafting
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoHalloweenOffering()
|
|
{
|
|
// Open it up!
|
|
if ( !m_pHalloweenOfferingPanel )
|
|
{
|
|
m_pHalloweenOfferingPanel = vgui::SETUP_PANEL( new CHalloweenOfferingPanel( this, m_pMouseOverTooltip ) );
|
|
m_pHalloweenOfferingPanel->InvalidateLayout( true, true );
|
|
}
|
|
// empty
|
|
CUtlVector< const CEconItemView* > vecSelectedItems;
|
|
m_pHalloweenOfferingPanel->Show( vecSelectedItems );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Craft Common StatClock
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoCraftCommonStatClock()
|
|
{
|
|
// Open it up!
|
|
if ( !m_pMannCoTradePanel )
|
|
{
|
|
m_pMannCoTradePanel = vgui::SETUP_PANEL( new CCraftCommonStatClockPanel( this, m_pMouseOverTooltip ) ); // make this more generic
|
|
m_pMannCoTradePanel->InvalidateLayout( true, true );
|
|
}
|
|
|
|
CUtlVector< CItemModelPanel* > vecSelected;
|
|
GetSelectedPanels(SELECT_ALL, vecSelected);
|
|
|
|
CUtlVector< const CEconItemView* > vecSelectedItems;
|
|
FOR_EACH_VEC(vecSelected, i)
|
|
{
|
|
if (vecSelected[i]->GetItem() && GetCraftCommonStatClockInvalidReason(vecSelected[i]->GetItem(), NULL) == NULL)
|
|
{
|
|
vecSelectedItems.AddToTail(vecSelected[i]->GetItem());
|
|
}
|
|
}
|
|
|
|
m_pMannCoTradePanel->Show( vecSelectedItems );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Bring up the 3D inspect panel for the selected item
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoInspectModel()
|
|
{
|
|
CUtlVector< CItemModelPanel* > vecSelected;
|
|
GetSelectedPanels( SELECT_FIRST, vecSelected );
|
|
|
|
if ( vecSelected.IsEmpty() )
|
|
return;
|
|
|
|
CEconItemView *pItem = vecSelected[0]->GetItem();
|
|
if ( pItem )
|
|
{
|
|
float flInspect = 0;
|
|
static CSchemaAttributeDefHandle pAttrib_WeaponAllowInspect( "weapon_allow_inspect" );
|
|
if ( ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pAttrib_WeaponAllowInspect, &flInspect ) && flInspect != 0.f )
|
|
#ifdef STAGING_ONLY
|
|
|| tf_weapon_force_allow_inspect.GetBool()
|
|
#endif
|
|
)
|
|
{
|
|
m_pInspectPanel->SetVisible( true );
|
|
m_pInspectPanel->SetItemCopy( vecSelected[0]->GetItem() );
|
|
}
|
|
else
|
|
{
|
|
for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_LAST_NORMAL_CLASS; ++iClass )
|
|
{
|
|
if ( pItem->GetStaticData()->CanBeUsedByClass( iClass ) )
|
|
{
|
|
m_pInspectCosmeticPanel->PreviewItem( iClass, pItem );
|
|
break;
|
|
}
|
|
}
|
|
m_pInspectCosmeticPanel->SetVisible( true );
|
|
}
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OpenInspectModelPanelAndCopyItem( CEconItemView *pItemView )
|
|
{
|
|
if ( !pItemView )
|
|
return;
|
|
|
|
EconUI()->OpenEconUI( ECONUI_BACKPACK );
|
|
|
|
// Figure out which preview to show
|
|
float flInspect = 0;
|
|
static CSchemaAttributeDefHandle pAttrib_WeaponAllowInspect( "weapon_allow_inspect" );
|
|
if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItemView, pAttrib_WeaponAllowInspect, &flInspect ) && flInspect != 0.f )
|
|
{
|
|
m_pInspectPanel->SetVisible( true );
|
|
m_pInspectPanel->SetItemCopy( pItemView );
|
|
}
|
|
else
|
|
{
|
|
for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_LAST_NORMAL_CLASS; ++iClass )
|
|
{
|
|
if ( pItemView->GetStaticData()->CanBeUsedByClass( iClass ) )
|
|
{
|
|
m_pInspectCosmeticPanel->PreviewItemCopy( iClass, pItemView );
|
|
m_pInspectCosmeticPanel->SetVisible( true );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CCollectionCraftingPanel* CBackpackPanel::GetCollectionCraftPanel()
|
|
{
|
|
if ( !m_pCollectionCraftPanel )
|
|
{
|
|
m_pCollectionCraftPanel = vgui::SETUP_PANEL( new CCollectionCraftingPanel( this, m_pMouseOverTooltip ) );
|
|
m_pCollectionCraftPanel->InvalidateLayout( true, true );
|
|
}
|
|
|
|
return m_pCollectionCraftPanel;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Buy a key, and then immediately use it on the selected crate once
|
|
// tbe store transaction completes
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoBuyKeyAndOpenCrate()
|
|
{
|
|
CUtlVector< CItemModelPanel* > vecSelected;
|
|
GetSelectedPanels( SELECT_FIRST, vecSelected );
|
|
|
|
if ( vecSelected.IsEmpty() )
|
|
return;
|
|
|
|
m_hQuickOpenCrate.SetItem( vecSelected.Head()->GetItem() );
|
|
|
|
uint32 iDecoableItemDef = 0;
|
|
if ( GetDecodedByItemDefIndex( m_hQuickOpenCrate, &iDecoableItemDef ) )
|
|
{
|
|
// casting to the proper type since our econ system is dumb
|
|
const float& value_as_float = (float&)iDecoableItemDef;
|
|
CEconItemDefinition * pDefIndex = GetItemSchema()->GetItemDefinition( (int)value_as_float );
|
|
|
|
EconUI()->GetStorePanel()->AddToCartAndCheckoutImmediately( pDefIndex->GetDefinitionIndex() );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find the first compatible key in our inventory, and use it on the
|
|
// selected crate
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoOpenCrateWithKey()
|
|
{
|
|
CUtlVector< CItemModelPanel* > vecSelected;
|
|
GetSelectedPanels( SELECT_FIRST, vecSelected );
|
|
|
|
if ( vecSelected.IsEmpty() )
|
|
return;
|
|
|
|
CEconItemView *pCrate = vecSelected.Head()->GetItem();
|
|
|
|
CEconItemView *pKey = GetFirstCompatibleKeyForCrate( pCrate );
|
|
if ( !pKey )
|
|
return;
|
|
|
|
ApplyTool( this, pKey, pCrate );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Open up the loadout for a class
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoEquipForClass( int nClass )
|
|
{
|
|
// Negative because reasons
|
|
EconUI()->OpenEconUI( -nClass );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Given a paint can index, offer to use one or buy one
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoPaint( int nPaintItemIndex, bool bUseStore, bool bUseMarket )
|
|
{
|
|
if ( !bUseStore && !bUseMarket )
|
|
{
|
|
AttemptToUseItem( nPaintItemIndex );
|
|
}
|
|
|
|
if ( bUseStore )
|
|
{
|
|
AttemptToShowItemInStore( nPaintItemIndex );
|
|
}
|
|
else if ( bUseMarket )
|
|
{
|
|
AttemptToShowItemInMarket( nPaintItemIndex );
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Given a strange part index, offer to use one or buy one (Market)
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::DoStrangePart( int nStrangePartIndex, bool bUseMarket )
|
|
{
|
|
if ( !bUseMarket )
|
|
{
|
|
AttemptToUseItem( nStrangePartIndex );
|
|
}
|
|
|
|
if ( bUseMarket )
|
|
{
|
|
AttemptToShowItemInMarket( nStrangePartIndex );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Try to find the first item with the passed-in item name in our inventory
|
|
// and try to use it on the selected panel's item. If we dont have an item
|
|
// matching the name passed in, go to the store and prompt the user to buy one.
|
|
//-----------------------------------------------------------------------------
|
|
bool CBackpackPanel::AttemptToUseItem( item_definition_index_t iItemDefIndex )
|
|
{
|
|
CUtlVector< CItemModelPanel* > m_vecSelected;
|
|
GetSelectedPanels( SELECT_FIRST, m_vecSelected );
|
|
Assert( m_vecSelected.Count() );
|
|
if ( !m_vecSelected.Count() )
|
|
return false;
|
|
|
|
CEconItemView *pSelectedItem = m_vecSelected.Head()->GetItem();
|
|
Assert( pSelectedItem );
|
|
if ( !pSelectedItem )
|
|
return false;
|
|
|
|
CEconItemView *pNameTag = CTFPlayerInventory::GetFirstItemOfItemDef( iItemDefIndex );
|
|
if ( pNameTag )
|
|
{
|
|
if ( ApplyTool( this, pNameTag, pSelectedItem ) )
|
|
{
|
|
CancelToolSelection();
|
|
UpdateModelPanels();
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::AttemptToShowItemInStore( item_definition_index_t iItemDefIndex )
|
|
{
|
|
CUtlVector< CItemModelPanel* > m_vecSelected;
|
|
GetSelectedPanels( SELECT_FIRST, m_vecSelected );
|
|
Assert( m_vecSelected.Count() );
|
|
if( !m_vecSelected.Count() )
|
|
return;
|
|
|
|
CEconItemView *pSelectedItem = m_vecSelected.Head()->GetItem();
|
|
Assert( pSelectedItem );
|
|
if ( !pSelectedItem )
|
|
return;
|
|
|
|
EconUI()->OpenStorePanel( iItemDefIndex, false );
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::AttemptToShowItemInMarket( item_definition_index_t iItemDefIndex )
|
|
{
|
|
CUtlVector< CItemModelPanel* > m_vecSelected;
|
|
GetSelectedPanels( SELECT_FIRST, m_vecSelected );
|
|
Assert( m_vecSelected.Count() );
|
|
if ( !m_vecSelected.Count() )
|
|
return;
|
|
|
|
CEconItemView *pSelectedItem = m_vecSelected.Head()->GetItem();
|
|
Assert( pSelectedItem );
|
|
if ( !pSelectedItem )
|
|
return;
|
|
|
|
CEconItemDefinition *pItemDef = GetItemSchema()->GetItemDefinition( iItemDefIndex );
|
|
Assert( pItemDef );
|
|
if ( !pItemDef )
|
|
return;
|
|
|
|
if ( !CBaseAdPanel::CheckForRequiredSteamComponents( "#StoreUpdate_SteamRequired", "#MMenu_OverlayRequired" ) )
|
|
return;
|
|
|
|
if ( pItemDef && steamapicontext && steamapicontext->SteamFriends() )
|
|
{
|
|
const char *pszPrefix = "";
|
|
if ( GetUniverse() == k_EUniverseBeta )
|
|
{
|
|
pszPrefix = "beta.";
|
|
}
|
|
|
|
static char pszItemName[256];
|
|
g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find( pItemDef->GetItemBaseName() ), pszItemName, sizeof( pszItemName ) );
|
|
|
|
char szURL[512];
|
|
V_snprintf( szURL, sizeof( szURL ), "http://%ssteamcommunity.com/market/listings/%d/%s", pszPrefix, engine->GetAppID(), pszItemName );
|
|
steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( szURL );
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the first, or all selected item model panels
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::GetSelectedPanels( ESelection eSelection, CUtlVector< CItemModelPanel* >& m_vecSelected ) const
|
|
{
|
|
for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
|
|
{
|
|
if ( m_pItemModelPanels[i]->IsSelected() && m_pItemModelPanels[i]->HasItem() )
|
|
{
|
|
m_vecSelected.AddToTail( m_pItemModelPanels[i] );
|
|
|
|
if ( eSelection == SELECT_FIRST )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OnCommand( const char *command )
|
|
{
|
|
if ( V_strncasecmp( command, "goto_page_", V_strlen( "goto_page_" ) ) == 0 )
|
|
{
|
|
int iPage = V_atoi( &command[ V_strlen( "goto_page_" ) ] );
|
|
SetCurrentPage( iPage );
|
|
UpdateModelPanels();
|
|
return;
|
|
}
|
|
else if ( !Q_strnicmp( command, "nextpage", 8 ) )
|
|
{
|
|
if ( !m_bDragging )
|
|
{
|
|
DeSelectAllBackpackItemPanels();
|
|
}
|
|
|
|
SetCurrentPage( GetCurrentPage() + 1 );
|
|
UpdateModelPanels();
|
|
return;
|
|
}
|
|
else if ( !Q_strnicmp( command, "prevpage", 8 ) )
|
|
{
|
|
if ( !m_bDragging )
|
|
{
|
|
DeSelectAllBackpackItemPanels();
|
|
}
|
|
|
|
SetCurrentPage( GetCurrentPage() - 1 );
|
|
UpdateModelPanels();
|
|
return;
|
|
}
|
|
else if ( !Q_strnicmp( command, "useitem", 7 ) )
|
|
{
|
|
AssertMsg( 0, "Everything should be going through the context menu. Fix the calling code." );
|
|
return;
|
|
}
|
|
else if ( !Q_strnicmp( command, "showbackpackitems", 17 ) )
|
|
{
|
|
SetShowBaseItems( false );
|
|
if ( m_pShowBaseItemsCheckbox )
|
|
{
|
|
m_pShowBaseItemsCheckbox->SetSelected( false );
|
|
}
|
|
return;
|
|
}
|
|
else if ( !Q_strnicmp( command, "showbaseitems", 13 ) )
|
|
{
|
|
SetShowBaseItems( true );
|
|
if ( m_pShowBaseItemsCheckbox )
|
|
{
|
|
m_pShowBaseItemsCheckbox->SetSelected( true );
|
|
}
|
|
return;
|
|
}
|
|
else if ( !Q_strnicmp( command, "canceltool", 10 ) )
|
|
{
|
|
CancelToolSelection();
|
|
UpdateModelPanels();
|
|
return;
|
|
}
|
|
else if ( !Q_stricmp( command, "show_explanations" ) )
|
|
{
|
|
if ( !m_flStartExplanationsAt )
|
|
{
|
|
m_flStartExplanationsAt = Plat_FloatTime();
|
|
vgui::ivgui()->AddTickSignal( GetVPanel() );
|
|
}
|
|
RequestFocus();
|
|
}
|
|
else if ( !Q_stricmp( command, "showdetails" ) )
|
|
{
|
|
for ( int i = 0; i < m_pItemModelPanels.Count(); i++ )
|
|
{
|
|
if ( m_pItemModelPanels[i]->IsSelected() && m_pItemModelPanels[i]->HasItem() )
|
|
{
|
|
OpenArmory( m_pItemModelPanels[i]->GetItem() );
|
|
break;
|
|
}
|
|
}
|
|
UpdateModelPanels();
|
|
return;
|
|
}
|
|
else if ( !V_strnicmp( command, "equipclass", 10 ) )
|
|
{
|
|
int nClass = atoi( command + 10 );
|
|
DoEquipForClass( nClass );
|
|
}
|
|
else if ( !V_strnicmp( command, "paint", 5 ) )
|
|
{
|
|
int nIndex = atoi( command + 5 );
|
|
DoPaint( nIndex, false, false );
|
|
}
|
|
else if ( !V_strnicmp( command, "market_paint", 12 ) )
|
|
{
|
|
int nIndex = atoi( command + 12 );
|
|
DoPaint( nIndex, false, true );
|
|
}
|
|
else if ( !V_strnicmp( command, "store_paint", 11 ) )
|
|
{
|
|
int nIndex = atoi( command + 11 );
|
|
DoPaint( nIndex, true, false );
|
|
}
|
|
else if ( !V_strnicmp( command, "strangepart_", 12 ) )
|
|
{
|
|
int nIndex = atoi( command + 12 );
|
|
DoStrangePart( nIndex, false );
|
|
}
|
|
else if ( !V_strnicmp( command, "market_strangepart_", 19 ) )
|
|
{
|
|
int nIndex = atoi( command + 19 );
|
|
DoStrangePart( nIndex, true );
|
|
}
|
|
else if ( !V_strnicmp( command, "Context_CraftUpCollection", 25 ) )
|
|
{
|
|
DoCraftUpCollection();
|
|
}
|
|
else if ( !V_strnicmp( command, "Context_CraftCommonStatClock", 25 ) )
|
|
{
|
|
DoCraftCommonStatClock();
|
|
}
|
|
#ifdef STAGING_ONLY
|
|
else if ( !V_strnicmp( command, "unpin", 5 ) )
|
|
{
|
|
m_pMouseOverCardPanel->PinCard( false );
|
|
}
|
|
#endif
|
|
|
|
BaseClass::OnCommand( command );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::OpenArmory( CEconItemView* item )
|
|
{
|
|
PostMessage( GetParent()->GetParent()->GetParent(), new KeyValues("OpenArmoryDirect", "itemdef", item->GetItemDefIndex() ) );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::CancelToolSelection( void )
|
|
{
|
|
if ( m_eSelectionMode == StandardSelection )
|
|
return;
|
|
|
|
m_eSelectionMode = StandardSelection;
|
|
|
|
ClearNameFilter( false );
|
|
|
|
OnCommand( "showbackpackitems" );
|
|
|
|
SetCurrentPage( m_nLastToolPage );
|
|
m_nLastToolPage = 0;
|
|
|
|
m_ToolSelectionItem.Invalidate();
|
|
if ( m_pToolIcon )
|
|
{
|
|
m_pToolIcon->SetVisible( false );
|
|
}
|
|
DeSelectAllBackpackItemPanels();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::SetShowBaseItems( bool bShow )
|
|
{
|
|
bool bGoToFirstPage = m_bShowBaseItems != bShow;
|
|
m_bShowBaseItems = bShow;
|
|
if( bGoToFirstPage )
|
|
{
|
|
SetCurrentPage( 0 );
|
|
}
|
|
|
|
DeSelectAllBackpackItemPanels();
|
|
if ( m_pToolIcon )
|
|
{
|
|
m_pToolIcon->SetVisible( false );
|
|
}
|
|
UpdateModelPanels();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
ConVar *CBackpackPanel::GetExplanationConVar( void )
|
|
{
|
|
return &tf_explanations_backpackpanel;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CBackpackPanel::SetCurrentPage( int nNewPage )
|
|
{
|
|
if( m_pToolIcon )
|
|
{
|
|
m_pToolIcon->SetVisible( false );
|
|
}
|
|
|
|
if ( nNewPage < 0 )
|
|
{
|
|
nNewPage = GetNumPages() - 1;
|
|
}
|
|
else if ( nNewPage >= GetNumPages() )
|
|
{
|
|
nNewPage = 0;
|
|
}
|
|
|
|
// deselect old page button
|
|
if ( m_Pages.Count() > GetCurrentPage() && m_Pages[GetCurrentPage()] )
|
|
{
|
|
CExButton* pButton = dynamic_cast<CExButton*>( m_Pages[GetCurrentPage()]->FindChildByName( "Button" ) );
|
|
if ( pButton )
|
|
{
|
|
pButton->SetSelected( false );
|
|
}
|
|
}
|
|
|
|
BaseClass::SetCurrentPage( nNewPage );
|
|
|
|
// mark new page button as selected
|
|
if ( m_Pages.Count() > GetCurrentPage() && m_Pages[GetCurrentPage()] )
|
|
{
|
|
CExButton* pButton = dynamic_cast<CExButton*>( m_Pages[GetCurrentPage()]->FindChildByName( "Button" ) );
|
|
if ( pButton )
|
|
{
|
|
pButton->SetSelected( true );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int CBackpackPanel::GetItemQualityForBorder( CItemModelPanel* pItemPanel ) const
|
|
{
|
|
if ( pItemPanel->HasItem() && ( cl_showbackpackrarities.GetInt() > 0 || m_bForceShowBackpackRarities )
|
|
&& ( cl_showbackpackrarities.GetInt() < 2 || pItemPanel->GetItem()->IsMarketable() ) )
|
|
{
|
|
uint8 nRarity = pItemPanel->GetItem()->GetItemDefinition()->GetRarity();
|
|
if ( ( nRarity != k_unItemRarity_Any ) && ( pItemPanel->GetItem()->GetItemQuality() != AE_SELFMADE ) )
|
|
{
|
|
// translate this quality to rarity
|
|
return nRarity + AE_RARITY_DEFAULT;
|
|
}
|
|
|
|
return pItemPanel->GetItem()->GetItemQuality();
|
|
}
|
|
|
|
return 0;
|
|
}
|