path: root/game/client/econ/item_model_panel.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//

#include "cbase.h"
#include "vgui/IInput.h"
#include <vgui/IVGui.h>
#include <vgui/IScheme.h>
#include "item_model_panel.h"
#include "iclientmode.h"
#include "baseviewport.h"
#include "econ_entity.h"
#include "gamestringpool.h"
#include "vgui_controls/TextImage.h"
#include "vgui_controls/Label.h"
#include "vgui_controls/Button.h"
#include "econ_item_system.h"
#include "ienginevgui.h"
#include "VGuiMatSurface/IMatSystemSurface.h"
#include "renderparm.h"
#include "vgui_controls/ScalableImagePanel.h"
#include "engine/IEngineSound.h"
#include "econ/tool_items/tool_items.h"
#include "econ_item_description.h"
#include "econ_item_tools.h"
#include "tool_items/custom_texture_cache.h"
#include "econ_dynamic_recipe.h"
#include "materialsystem/imaterialvar.h"
#include "materialsystem/itexturecompositor.h"
#include "bone_setup.h"
#include "animation.h"
#include "iconrenderreceiver.h"

#ifdef TF_CLIENT_DLL
#include "tf_shareddefs.h"
#include "tf_gamerules.h"
#endif // TF_CLIENT_DLL
#include "KeyValues.h"

ConVar tf_time_loading_item_panels( "tf_time_loading_item_panels", "0.0005", FCVAR_ARCHIVE, "The time to spend per frame loading data for item panels" );
#ifdef STAGING_ONLY
ConVar tf_paint_kit_show_unique_icon( "tf_paint_kit_show_unique_icon", "1" );
ConVar tf_test_loading_panels( "tf_test_loading_panels", "0" );
ConVar tf_force_highres_item_image( "tf_force_highres_item_image", "0" );
ConVar tf_unique_icon_perf_debug( "tf_unique_icon_perf_debug", "0" );
#endif

const char* g_ItemModelPanelRenderTargetNames[] =
{
	"_rt_ItemModelPanel0",
	"_rt_ItemModelPanel1",
	"_rt_ItemModelPanel2"
};
COMPILE_TIME_ASSERT( ITEM_MODEL_IMAGE_CACHE_SIZE == ARRAYSIZE( g_ItemModelPanelRenderTargetNames ) );

CItemMaterialCustomizationIconPanel::CItemMaterialCustomizationIconPanel( vgui::Panel *pParent, const char *pName ) 
	: BaseClass( pParent, pName )
{
	m_iPaintSplat = -1;
}

CItemMaterialCustomizationIconPanel::~CItemMaterialCustomizationIconPanel()
{
	if ( vgui::surface() )
	{
		if ( m_iPaintSplat != -1 )
		{
			vgui::surface()->DestroyTextureID( m_iPaintSplat );
			m_iPaintSplat = -1;
		}
	}
}

// Custom painting
void CItemMaterialCustomizationIconPanel::PaintBackground( void )
{
	// Draw custom texture, if we have one
	if ( m_hUGCId != 0 )
	{
		// Request it from the cache, and get filename, if it's downloaded
		// and ready
		int iCustomTexture = GetCustomTextureGuiHandle( m_hUGCId );
		if ( iCustomTexture != 0 )
		{
			surface()->DrawSetTexture( iCustomTexture );
			DrawQuad( 0, 1 );
			surface()->DrawSetColor(COLOR_WHITE);
		}
	}

	for ( int i = 0; i < m_colPaintColors.Size(); i++ )
	{
		const Color& c = m_colPaintColors[i];

		if ( m_iPaintSplat == -1 )
		{
			m_iPaintSplat = surface()->CreateNewTextureID();
			surface()->DrawSetTextureFile( m_iPaintSplat, "vgui/backpack_jewel_paint_splatter", true, false);
		}
		surface()->DrawSetTexture( m_iPaintSplat );
		surface()->DrawSetColor( c.r(), c.g(), c.b(), GetAlpha() );
		DrawQuad( i, m_colPaintColors.Size() );
		surface()->DrawSetColor(COLOR_WHITE);
	}

	// Clean up
	vgui::surface()->DrawSetTexture(0);
}

// Draw a quad that fills our extents
void CItemMaterialCustomizationIconPanel::DrawQuad( int iSubtileIndex, int iSubtileCount )
{
	int iWide, iTall;
	GetSize( iWide, iTall );

	// All of this math is to accomplish the following: allow us to split our single "icon"
	// into some number of equivalent columns. Then take each column and angle the divider so
	// it goes from the left image to the right image:
	//
	//			+-----+-----+				+------+----+
	//			|	  |     |				|     /		|
	//			|	  |	    |				|     |		|
	//			|	  |	    |				|	  /		|
	//			+-----+-----+				+--- +------+
	//
	// ...because the angle is prettier than a straight vertical cut.
	//
	// My hope is that this code is so awful I'm never allowed to write UI code again.
	float fXScale   = 1.0f / (float)iSubtileCount,
			fXOffsetL = (float)iSubtileIndex * fXScale,
			fXOffsetR = (float)(iSubtileIndex + 1) * fXScale,
			fXUpperLowerOffset = fXScale * 0.65f;

	// We shift our coordinates on the top slightly to the right (by fXUpperLowerOffset) and on
	// the bottom slightly to the left (also by fXUpperLowerOffset). The far left side can't move
	// away from 0 and the far right side can't move away from 1, so the edge case handling makes
	// this look uglier than it really is.
	float fXUL = iSubtileIndex == 0 ? fXOffsetL : fXOffsetL + fXUpperLowerOffset,
			fXUR = iSubtileIndex == iSubtileCount - 1 ? fXOffsetR : fXOffsetR + fXUpperLowerOffset,
			fXBL = iSubtileIndex == 0 ? fXOffsetL : fXOffsetL - fXUpperLowerOffset,
			fXBR = iSubtileIndex == iSubtileCount - 1 ? fXOffsetR : fXOffsetR - fXUpperLowerOffset;

	Vector2D uv11( fXUL, 0.0f );
	Vector2D uv21( fXUR, 0.0f );
	Vector2D uv22( fXBR, 1.0f );
	Vector2D uv12( fXBL, 1.0f );

	vgui::Vertex_t verts[4];
	verts[0].Init( Vector2D( iWide * fXUL,	0 ),	 uv11 );
	verts[1].Init( Vector2D( iWide * fXUR, 0 ),	 uv21 );
	verts[2].Init( Vector2D( iWide * fXBR, iTall ), uv22 );
	verts[3].Init( Vector2D( iWide * fXBL,	iTall ), uv12  );

	vgui::surface()->DrawTexturedPolygon( 4, verts );	
}

DECLARE_BUILD_FACTORY( CItemModelPanel );
DECLARE_BUILD_FACTORY( CEmbeddedItemModelPanel );
DECLARE_BUILD_FACTORY( CItemMaterialCustomizationIconPanel );

item_model_cache_t g_ItemModelImageCache[ITEM_MODEL_IMAGE_CACHE_SIZE];

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CEmbeddedItemModelPanel::CEmbeddedItemModelPanel( vgui::Panel *pParent, const char *pName ) : BaseClass( pParent, pName )
{
	m_bUseItemRenderTarget = false;
	m_bForceUseModel = false;
	m_pItem = NULL;
	m_pszToolTargetItemImage = NULL;
	m_iTextureID = -1;
	m_iToolTargetItemTextureID = -1;
	m_iOverlayTextureIDs.SetLessFunc( DefLessFunc(int) );
	m_iOverlayTextureIDs.Purge();
	m_bImageNotLoaded = false;
	m_bGreyedOut = false;
	m_bModelIsHidden = false;
	m_bUseRenderTargetAsIcon = false;

	m_bWeaponAllowInspect = false;
	m_pCachedWeaponIcon = NULL;
	m_pCachedWeaponMaterial = NULL;
	m_iCachedTextureID = -1;

	m_flModelRotateYawSpeed = 0;

	m_bUsePedestal = false;
	m_bOfflineIconGeneration = false;

	m_pItemParticle = NULL;

#ifdef STAGING_ONLY
	m_flStartUpdateTime = 0.0;
#endif // STAGING_ONLY
}


CEmbeddedItemModelPanel::~CEmbeddedItemModelPanel()
{
	CleanUpCachedWeaponIcon();

	SafeDeleteParticleData( &m_pItemParticle );
}


void CEmbeddedItemModelPanel::CleanUpCachedWeaponIcon()
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );

	SafeRelease( &m_pCachedWeaponIcon );
	SafeRelease( &m_pCachedWeaponMaterial );

	if ( m_iCachedTextureID != -1 )
	{
		surface()->DeleteTextureByID( m_iCachedTextureID );
		m_iCachedTextureID = -1;
	}

	// If we match a cache here, clear it so we redraw once when we appear.
	for ( int i = 0; i < ITEM_MODEL_IMAGE_CACHE_SIZE; i++ )
	{
		bool bMatch = g_ItemModelImageCache[i].m_hModelPanelLock.Get() == this;
		if ( bMatch )
		{
			g_ItemModelImageCache[i].Clear();
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEmbeddedItemModelPanel::UpdateCameraForIcon()
{
	if ( m_iCameraAttachment == -1 )
		return;

	studiohdr_t *pItemStudioHdr = m_RootMDL.m_MDL.GetStudioHdr();
	if ( pItemStudioHdr )
	{
		matrix3x4_t matBoneToWorld[MAXSTUDIOBONES];
		m_RootMDL.m_MDL.SetUpBones( m_RootMDL.m_MDLToWorld, MAXSTUDIOBONES, matBoneToWorld );

		// Get attachment transform
		mstudioattachment_t attach = pItemStudioHdr->pAttachment( m_iCameraAttachment );
		matrix3x4_t matLocalToWorld;
		ConcatTransforms( matBoneToWorld[ attach.localbone ], attach.local, matLocalToWorld );

		QAngle angCameraAngles;
		Vector vecCameraPos;
		MatrixAngles( matLocalToWorld, angCameraAngles, vecCameraPos );
		SetCameraOffset( vec3_origin );
		SetCameraPositionAndAngles( vecCameraPos, angCameraAngles );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEmbeddedItemModelPanel::SetItem( CEconItemView *pItem ) 
{ 
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );

	m_iTextureID = -1; 
	m_iToolTargetItemTextureID = -1;
	m_iOverlayTextureIDs.Purge();
	CleanUpCachedWeaponIcon();
	SafeDeleteParticleData( &m_pItemParticle );

	// reset all models
	SetMDL( MDLHANDLE_INVALID );
	m_ItemModel.m_bDisabled = true;
	m_ItemModel.m_MDL.SetMDL( MDLHANDLE_INVALID );
	m_StatTrackModel.m_bDisabled = true;
	m_StatTrackModel.m_MDL.SetMDL( MDLHANDLE_INVALID );

	m_AttachedModels.Purge();

	m_iCameraAttachment = -1;

	m_pItem = pItem;

	if ( !m_pItem )
		return;

	const char* pszInventoryImage = m_pItem->IsValid() ? m_pItem->GetInventoryImage() : NULL;
	if ( ( pszInventoryImage && pszInventoryImage[0] && !g_pMaterialSystem->IsMaterialLoaded( pszInventoryImage ) )
#ifdef STAGING_ONLY
		|| tf_test_loading_panels.GetBool()
#endif
		)
	{
		m_bImageNotLoaded = true;
	}

	if ( !m_pItem->IsValid() )
		return;

	float flValue;
	static CSchemaAttributeDefHandle pAttrib_ToolTarget( "tool target item" );
	if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( m_pItem, pAttrib_ToolTarget, &flValue ) )
	{
		const CEconItemDefinition *pTargetDef = GetItemSchema()->GetItemDefinition( flValue );

		m_pszToolTargetItemImage = pTargetDef->GetInventoryImage();
	}
	else
	{
		m_pszToolTargetItemImage = NULL;
	}
   
#ifdef STAGING_ONLY
	if ( tf_paint_kit_show_unique_icon.GetBool() )
#endif // STAGING_ONLY
	{
		float flInspect = 0;
		static CSchemaAttributeDefHandle pAttrib_WeaponAllowInspect( "weapon_allow_inspect" );
		if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( m_pItem, pAttrib_WeaponAllowInspect, &flInspect ) )
		{
			m_bWeaponAllowInspect = flInspect != 0;

#ifdef STAGING_ONLY
			if ( m_flStartUpdateTime == 0 )
				m_flStartUpdateTime = Plat_FloatTime();
#endif // STAGING_ONLY
		}
		else
		{
			m_bWeaponAllowInspect = false;
			
#ifdef STAGING_ONLY
			m_flStartUpdateTime = 0.0;
#endif // STAGING_ONLY
		}
	}

	float flUseCacheIcon = 0.f;
	static CSchemaAttributeDefHandle pAttrib_UseModelCacheIcon( "use_model_cache_icon" );
	if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( m_pItem, pAttrib_UseModelCacheIcon, &flUseCacheIcon ) && flUseCacheIcon != 0.f )
	{
		m_bUseRenderTargetAsIcon = true;
	}
	else
	{
		m_bUseRenderTargetAsIcon = false;
	}

	if ( !m_bModelIsHidden )
	{
		if ( !m_pItem->GetInventoryImage() || IsForcingModelUsage() || m_bWeaponAllowInspect || UseRenderTargetAsIcon() )
		{
			const char *pszModelName = m_pItem->GetPlayerDisplayModel( 0, 0 );
			if ( pszModelName )
			{
				CMDL *pMDL = NULL;
#ifndef PORTAL2 // DOTA COME BACK
				if ( m_bUsePedestal )
				{
					MDLHandle_t hPedestalMDL = mdlcache->FindMDL( "models/weapons/pedestal/pedestal.mdl" ); 
					SetMDL( hPedestalMDL, NULL );
					mdlcache->Release( hPedestalMDL ); // counterbalance addref from within FindMDL

					MDLHandle_t hItemMDL = mdlcache->FindMDL( pszModelName );
					if ( mdlcache->IsErrorModel( hItemMDL ) )
					{
						hItemMDL = MDLHANDLE_INVALID;
					}
					m_ItemModel.m_MDL.SetMDL( hItemMDL );
					mdlcache->Release( hItemMDL ); // counterbalance addref from within FindMDL

					pMDL = &m_ItemModel.m_MDL;
				}
				else
				{
					MDLHandle_t hMDL = mdlcache->FindMDL( pszModelName );
					SetMDL( hMDL, static_cast<IClientRenderable*>( m_pItem ) );
					mdlcache->Release( hMDL ); // counterbalance addref from within FindMDL

					pMDL = &m_RootMDL.m_MDL;
				}
#endif

				if ( pMDL )
				{
					studiohdr_t *pItemStudioHdr = pMDL->GetStudioHdr();
					if ( pItemStudioHdr )
					{
						// Get the appropriate attachment
						CStudioHdr HDR( pItemStudioHdr, g_pMDLCache );
						if ( m_bUsePedestal )
						{
							m_iPedestalAttachment = Studio_FindAttachment( &HDR, "pedestal_0" );
							if ( m_iPedestalAttachment != -1 )
							{
								m_ItemModel.m_MDL.m_pProxyData = static_cast<IClientRenderable*>(m_pItem);
								m_ItemModel.m_bDisabled = false;
								m_ItemModel.m_MDL.m_nSequence = ACT_IDLE;
								SetIdentityMatrix( m_ItemModel.m_MDLToWorld );
							}
						}
						else
						{
							m_iCameraAttachment = Studio_FindAttachment( &HDR, "icon_camera" );
							UpdateCameraForIcon();
						}

						// should we override this model bodygroup
						const CEconStyleInfo *pStyle = m_pItem->GetItemDefinition()->GetStyleInfo( m_pItem->GetStyle() );
						if ( pStyle && pStyle->GetBodygroupName() != NULL )
						{
							int iBodyGroup = ::FindBodygroupByName( &HDR, pStyle->GetBodygroupName() );
							if ( iBodyGroup != -1 )
							{
								::SetBodygroup( &HDR, pMDL->m_nBody, iBodyGroup, pStyle->GetBodygroupSubmodelIndex() );
							}
						}
					}
				}

				// Attach Models
				// Attach the models for the item
				{
					int iTeam = m_pItem->GetItemDefinition()->GetBestVisualTeamData( m_pItem->GetTeamNumber() );
					{
						// Set attached models if viewable third-person.
						const int iNumAttachedModels = m_pItem->GetItemDefinition()->GetNumAttachedModels( iTeam );
						for ( int i = 0; i < iNumAttachedModels; ++i )
						{
							attachedmodel_t	*pModel = m_pItem->GetItemDefinition()->GetAttachedModelData( iTeam, i );
							LoadAttachedModel( pModel );
						}
					}

					// Festive
					static CSchemaAttributeDefHandle pAttr_is_festivized( "is_festivized" );
					if ( pAttr_is_festivized && m_pItem->FindAttribute( pAttr_is_festivized ) )
					{
						const int iNumAttachedModels = m_pItem->GetItemDefinition()->GetNumAttachedModelsFestivized( iTeam );
						for ( int i = 0; i < iNumAttachedModels; ++i )
						{
							attachedmodel_t	*pModel = m_pItem->GetItemDefinition()->GetAttachedModelDataFestivized( iTeam, i );
							LoadAttachedModel( pModel );
						}
					}
				}

				// Stattrak
				CAttribute_String attrModule;
				static CSchemaAttributeDefHandle pAttr_module( "weapon_uses_stattrak_module" );
				if ( m_pItem->FindAttribute( pAttr_module, &attrModule ) && attrModule.has_value() )
				{
					// Allow for already strange items
					bool bIsStrange = false;
					if ( m_pItem->GetQuality() == AE_STRANGE )
					{
						bIsStrange = true;
					}

					if ( !bIsStrange )
					{
						// Go over the attributes of the item, if it has any strange attributes the item is strange and don't apply
						for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
						{
							if ( m_pItem->FindAttribute( GetKillEaterAttr_Score( i ) ) )
							{
								bIsStrange = true;
								break;
							}
						}
					}

					if ( bIsStrange )
					{
						static CSchemaAttributeDefHandle pAttr_moduleScale( "weapon_stattrak_module_scale" );
						// Does it have a stat track module
						m_flStatTrackScale = 1.0f;
						uint32 unFloatAsUint32 = 1;
						if ( m_pItem->FindAttribute( pAttr_moduleScale, &unFloatAsUint32 ) )
						{
							m_flStatTrackScale = (float&)unFloatAsUint32;
						}

						MDLHandle_t hStatTrackMDL = mdlcache->FindMDL( "models/weapons/c_models/stattrack.mdl" );
						if ( mdlcache->IsErrorModel( hStatTrackMDL ) )
						{
							hStatTrackMDL = MDLHANDLE_INVALID;
						}
						m_StatTrackModel.m_MDL.SetMDL( hStatTrackMDL );
						mdlcache->Release( hStatTrackMDL ); // counterbalance addref from within FindMDL

						m_StatTrackModel.m_MDL.m_pProxyData = static_cast<IClientRenderable*>(pItem);
						m_StatTrackModel.m_bDisabled = false;
						m_StatTrackModel.m_MDL.m_nSequence = ACT_IDLE;
						SetIdentityMatrix( m_StatTrackModel.m_MDLToWorld );
					}
				}

				int iTeam = GetLocalPlayerTeam(),
					iSkin = iTeam;

#ifdef TF_CLIENT_DLL
				// If we aren't in a game we default to previewing the red team skin.
				if ( iTeam == TEAM_UNASSIGNED )
				{
					iTeam = TF_TEAM_RED;
				}
#endif // TF_CLIENT_DLL

				if ( iSkin != TEAM_UNASSIGNED )
				{
					// Use the first skin for the first team, and the second skin for the other (but default to 0)
					iSkin = (iSkin == (FIRST_GAME_TEAM+1)) ? 1 : 0;
				}

				// Handle styles/visuals overriding the skin.
				int iOverrideSkin = m_pItem->GetSkin( iTeam );
				if ( iOverrideSkin != -1 )
				{
					iSkin = iOverrideSkin;
				}
					
				SetSkin( iSkin );

				if ( m_bUsePedestal )
				{
					m_ItemModel.m_MDL.m_nSkin = iSkin;
				}
			}
		}
	}
}

void CEmbeddedItemModelPanel::LoadAttachedModel( attachedmodel_t *pModel )
{
	if ( !( pModel->m_iModelDisplayFlags & kAttachedModelDisplayFlag_WorldModel ) )
		return;

	if ( !pModel->m_pszModelName )
	{
		Warning( "econ item definition '%s' attachment has no model\n", m_pItem->GetItemDefinition()->GetDefinitionName() );
		return;
	}

	int iIndex = m_AttachedModels.AddToTail();
	MDLHandle_t hMDL = mdlcache->FindMDL( pModel->m_pszModelName );
	if ( mdlcache->IsErrorModel( hMDL ) )
	{
		hMDL = MDLHANDLE_INVALID;
	}
	m_AttachedModels[iIndex].m_MDL.SetMDL( hMDL );
	mdlcache->Release( hMDL ); // counterbalance addref from within FindMDL

	m_AttachedModels[iIndex].m_MDL.m_pProxyData = static_cast<IClientRenderable*>( m_pItem );
	m_AttachedModels[iIndex].m_bDisabled = false;
	m_AttachedModels[iIndex].m_MDL.m_nSequence = ACT_IDLE;
	SetIdentityMatrix( m_AttachedModels[iIndex].m_MDLToWorld );
}

bool CEmbeddedItemModelPanel::IsLoadingWeaponSkin( void ) const
{
	static ConVarRef mat_dxlevel( "mat_dxlevel" );
	if ( mat_dxlevel.GetInt() < 90 )
		return false;

	if ( m_bForceUseModel )
		return false;

	if ( m_pItem && m_pItem->IsValid() )
	{
		if ( m_bWeaponAllowInspect && m_pItem->GetCustomPainkKitDefinition() )
		{
			return m_pItem->GetWeaponSkinBaseCompositor() != NULL || !m_pCachedWeaponIcon || !m_pCachedWeaponIcon->GetTexture();
		}
		else if ( UseRenderTargetAsIcon() )
		{
			return !m_pCachedWeaponIcon || !m_pCachedWeaponIcon->GetTexture();
		}
	}
	
	return false;
}


bool CEmbeddedItemModelPanel::IsImageNotLoaded( void ) const
{
	if ( m_bForceUseModel )
		return false;

	if ( m_bImageNotLoaded && m_pItem && m_pItem->IsValid() )
		return true;

	return false;
}


IMaterial* GetMaterialForImage( CEmbeddedItemModelPanel::InventoryImageType_t eImageType, const char* pszBaseName )
{
	IMaterial *pMaterial = NULL;
	
	Assert( pszBaseName );
	if ( !pszBaseName )
		return NULL;

#ifdef STAGING_ONLY
	if ( eImageType == CEmbeddedItemModelPanel::IMAGETYPE_SMALL && tf_force_highres_item_image.GetBool() )
	{
		eImageType = CEmbeddedItemModelPanel::IMAGETYPE_LARGE;
	}
#endif // STAGING_ONLY

	switch ( eImageType )
	{
	case CEmbeddedItemModelPanel::IMAGETYPE_SMALL:
		pMaterial = g_pMaterialSystem->FindMaterial( pszBaseName, TEXTURE_GROUP_VGUI );
		break;
	case CEmbeddedItemModelPanel::IMAGETYPE_DETAILED:
		pMaterial = g_pMaterialSystem->FindMaterial( CFmtStr("%s_detail",pszBaseName).Access(), TEXTURE_GROUP_VGUI, false );
		break;
	case CEmbeddedItemModelPanel::IMAGETYPE_LARGE:
		pMaterial = g_pMaterialSystem->FindMaterial( CFmtStr("%s_large",pszBaseName).Access(), TEXTURE_GROUP_VGUI );
		break;
	default:
		Assert(0);
	}
	
	Assert( pMaterial && !IsErrorMaterial( pMaterial ) );

	return pMaterial;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEmbeddedItemModelPanel::LoadInventoryImage()
{
	InventoryImageType_t type = (InventoryImageType_t)m_iInventoryImageType;
	if ( m_iInventoryImageType == IMAGETYPE_DETAILED && !m_pItem->GetStaticData()->HasDetailedIcon() )
	{
		type = IMAGETYPE_LARGE;
	}
	GetMaterialForImage( type, m_pItem->GetInventoryImage() );
	m_bImageNotLoaded = false;
	m_iTextureID = -1;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEmbeddedItemModelPanel::PerformLayout( void )
{
	BaseClass::PerformLayout();

	CleanUpCachedWeaponIcon();

	// Nive the "player pos" to the defined distance
	if ( m_pItem && m_pItem->IsValid() )
	{
		if ( m_bUsePedestal )
		{
			Vector vecOffset = m_BMPResData.m_vecOriginOffset;
			vecOffset.x = m_pItem->GetItemDefinition()->GetInspectPanelDistance();
			// reset model angle and pos to initial values
			SetModelAnglesAndPosition( m_BMPResData.m_angModelPoseRot, vecOffset );
		}
		else if ( m_iCameraAttachment != -1 )
		{
			UpdateCameraForIcon();
		}
	}
}

#ifdef STAGING_ONLY
static double s_min_time = FLT_MAX;
static double s_max_time = 0.f;
static double s_total_time = 0.f;
#endif // STAGING_ONLY

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEmbeddedItemModelPanel::Paint( void )
{
	if ( !m_pItem || !m_pItem->IsValid() )
		return;

	if ( m_bModelIsHidden )
	{
		BaseClass::Paint();
		return;
	}

	// Don't even try to render backpack icon if we're not loaded
	if ( m_bImageNotLoaded && !m_bWeaponAllowInspect && !UseRenderTargetAsIcon() )
		return;

	const char *pszInventoryImage = m_pItem->GetInventoryImage();

	CMatRenderContextPtr pRenderContext( materials );

	int iWidth = GetWide();
	int iHeight = GetTall();
	float flTexW = 1.0;
	float flTexH = 1.0;
	float flTexX = 0.0;
	float flTexY = 0.0;
	int x = 0;
	int y = 0;

	// First, try and use the inventory image instead of the model.
	bool bIsLoadingWeaponSkin = IsLoadingWeaponSkin();

	int iTexture = -1;
	if ( !bIsLoadingWeaponSkin && !m_bForceUseModel )
	{
		// should we override material with cache texture
		if ( m_pCachedWeaponIcon && m_pCachedWeaponIcon->GetTexture() )
		{
			// Clear out the composited texture--we're finished with it.
			m_pItem->SetWeaponSkinBase( NULL );
			// The compositor should have been cleaned up by the material proxy.
			Assert( m_pItem->GetWeaponSkinBaseCompositor() == NULL );

			if ( !m_pCachedWeaponMaterial && g_pMaterialSystem )
			{
				const char *pszTextureName = m_pCachedWeaponIcon->GetTexture()->GetName();
				KeyValues *pVMTKeyValues = new KeyValues( "UnlitGeneric" );
				pVMTKeyValues->SetString( "$basetexture", pszTextureName );
				pVMTKeyValues->SetInt( "$translucent", 1 );
				pVMTKeyValues->SetInt( "$vertexcolor", 1 );
				IMaterial *pMaterial = g_pMaterialSystem->FindProceduralMaterial( pszTextureName, TEXTURE_GROUP_VGUI, pVMTKeyValues );
				SafeAssign( &m_pCachedWeaponMaterial, pMaterial );

				bool bFound = false;
				IMaterialVar *pVar = m_pCachedWeaponMaterial->FindVar( "$basetexture", &bFound );
				if ( bFound && pVar )
				{
					pVar->SetTextureValue( m_pCachedWeaponIcon->GetTexture() );
					m_pCachedWeaponMaterial->RefreshPreservingMaterialVars();
				}
			}

			if ( m_iCachedTextureID == -1 )
			{
				//m_pCachedWeaponIcon->GetTexture()->SaveToFile( CFmtStr( "%d_weapon_skin_cache.tga", m_pItem->GetItemDefIndex() ) );
				m_iCachedTextureID = g_pMatSystemSurface->DrawGetTextureId( m_pCachedWeaponIcon->GetTexture() );
				g_pMatSystemSurface->DrawSetTextureMaterial( m_iCachedTextureID, m_pCachedWeaponMaterial );
			}
			iTexture = m_iCachedTextureID;
			x = 0;
			y = 0;
			flTexX = flTexY = 0.f;

			int iMappingWidth = m_pCachedWeaponMaterial->GetMappingWidth();
			int iMappingHeight = m_pCachedWeaponMaterial->GetMappingHeight();
			if ( iWidth > iMappingWidth || iHeight > iMappingHeight )
			{
				flTexW = 1.f;
				flTexH = 1.f;
			}
			else
			{
				flTexW = (float)iWidth / iMappingWidth;
				flTexH = (float)iHeight / iMappingHeight;
			}

#ifdef STAGING_ONLY
			if ( tf_unique_icon_perf_debug.GetBool() && m_flStartUpdateTime != 0 )
			{
				double flTimeTaken = Plat_FloatTime() - m_flStartUpdateTime;
				m_flStartUpdateTime = 0.0;
				s_min_time = MIN( s_min_time, flTimeTaken );
				s_max_time = MAX( s_max_time, flTimeTaken );
				s_total_time += flTimeTaken;
				DevMsg( "took %.3f with min %.3f max %.3f with total %.3f\n", flTimeTaken, s_min_time, s_max_time, s_total_time );
			}
#endif // STAGING_ONLY
		}
		else if ( pszInventoryImage )
		{
			// Look up the material (use the large one if we've been told to)
			IMaterial *pMaterial = GetMaterialForImage( (CEmbeddedItemModelPanel::InventoryImageType_t)m_iInventoryImageType, pszInventoryImage );
		
			int iCenter[2];
			iCenter[0] = x + (iWidth * 0.5);
			iCenter[1] = y + (iHeight * 0.5);

			// Maintain image aspect ratios. Fit to height.
			int iPosition[2] = {0,0};
			int iSize[2] = {0,0};
			m_pItem->GetInventoryImageData( iPosition, iSize );
		
			if ( m_bForceSquareImage )
			{
				iSize[0] = MAX( iSize[0], iSize[1] );
				iSize[1] = iSize[0];
			}
			if ( !iSize[0] && !iSize[1] )
			{
				iSize[0] = pMaterial->GetMappingWidth();
				iSize[1] = pMaterial->GetMappingHeight();
			}
			else
			{
				bool bForceHighRes = false;
#ifdef STAGING_ONLY
				bForceHighRes = tf_force_highres_item_image.GetBool();
#endif // STAGING_ONLY
				if ( m_iInventoryImageType != IMAGETYPE_SMALL || bForceHighRes )
				{
					// Normal is 128*128, large is 512x512
					iSize[0] *= 4;
					iSize[1] *= 4;
				}

				flTexW = ((float)iSize[0] / (float)pMaterial->GetMappingWidth());
				flTexH = ((float)iSize[1] / (float)pMaterial->GetMappingHeight());
				flTexX = ( 1.0 - flTexW ) * 0.5;
				flTexY = ( 1.0 - flTexH ) * 0.5;
			}
			if ( iPosition[0] || iPosition[1] )
			{
				x += XRES(iPosition[0]);
				y += YRES(iPosition[1]);
			}

			float flRatio = ((float)iSize[0] / (float)iSize[1]);
			if ( flRatio != ((float)iWidth / (float)iHeight) )
			{
				// Fit to the height
				int iCenterX = x + (iWidth * 0.5);
				iWidth = iHeight * flRatio;
				x = iCenterX - (iWidth * 0.5);
			}

			// Reload our texture, if we need to
			if ( m_iTextureID == -1 ) 
			{
				m_iTextureID = vgui::surface()->DrawGetTextureId( pMaterial->GetName() );

				// If we didn't find it, create a new one
				if ( m_iTextureID == -1 )
				{
					m_iTextureID = vgui::surface()->CreateNewTextureID();	
					g_pMatSystemSurface->DrawSetTextureMaterial( m_iTextureID, pMaterial );
				}
			}

			iTexture = m_iTextureID;
		}
	}

	// draw texture if we have a valid texture
	if ( iTexture != -1 )
	{
		surface()->DrawSetTexture( iTexture );

		if ( m_bGreyedOut )
		{ 
			surface()->DrawSetColor( 96, 96, 96, 255 );
		}
		else
		{
			surface()->DrawSetColor( 255, 255, 255, 255 );
		}
		surface()->DrawTexturedSubRect( x, y, x + iWidth, y + iHeight, flTexX, flTexY, flTexX + flTexW, flTexY + flTexH );

		// Draw the overlay image now, and tint it by the tint attribute (if we have one)
		for ( int i=0; i<m_pItem->GetInventoryOverlayImageCount(); i++ )
		{
			const char *pszInventoryOverlayImage = m_pItem->GetInventoryOverlayImage( i );
			IMaterial *pOverlayMaterial = GetMaterialForImage( (CEmbeddedItemModelPanel::InventoryImageType_t)m_iInventoryImageType, pszInventoryOverlayImage );

			if ( !pOverlayMaterial )
				continue;

			int iTextureIDIdx = m_iOverlayTextureIDs.Find(i);
			if ( (iTextureIDIdx == m_iOverlayTextureIDs.InvalidIndex()
				|| m_iOverlayTextureIDs[iTextureIDIdx] == -1 ) )
			{
				int iTextureID = vgui::surface()->DrawGetTextureId( pOverlayMaterial->GetName() );

				// If we didn't find it, create a new one
				if ( iTextureID == -1 )
				{
					iTextureID = vgui::surface()->CreateNewTextureID();	
					g_pMatSystemSurface->DrawSetTextureMaterial( iTextureID, pOverlayMaterial );
				}

				m_iOverlayTextureIDs.Insert( i, iTextureID );
			}

			surface()->DrawSetTexture( m_iOverlayTextureIDs[m_iOverlayTextureIDs.Find( i )] );

			int iRGB = m_pItem->GetModifiedRGBValue( i == 0 );
			Color col;
			col.SetColor( clamp( (iRGB & 0xFF0000) >> 16, 0, 255 ), clamp( (iRGB & 0xFF00) >> 8, 0, 255 ), clamp( (iRGB & 0xFF), 0, 255 ), 255 );
			// Dim this color if the item is currently greyed out
			float flColorScale = m_bGreyedOut ? 96.f / 255.f : 1.f;
			col.SetColor( col.r() * flColorScale, col.g() * flColorScale, col.b() * flColorScale, col.a() );

			surface()->DrawSetColor( col );

			surface()->DrawTexturedSubRect( x, y, x + iWidth, y + iHeight, flTexX, flTexY, flTexX + flTexW, flTexY + flTexH );
		}

		// Draw strangifier item on top of strangifier bottles
		if ( m_pszToolTargetItemImage && m_pszToolTargetItemImage[0] )
		{
			IMaterial* pToolTargetItemMaterial = GetMaterialForImage( (CEmbeddedItemModelPanel::InventoryImageType_t)m_iInventoryImageType, m_pszToolTargetItemImage );
			
			if ( m_iToolTargetItemTextureID == -1 ) 
			{
				m_iToolTargetItemTextureID = vgui::surface()->DrawGetTextureId( pToolTargetItemMaterial->GetName() );

				// If we didn't find it, create a new one
				if ( m_iToolTargetItemTextureID == -1 )
				{
					m_iToolTargetItemTextureID = vgui::surface()->CreateNewTextureID();	
					g_pMatSystemSurface->DrawSetTextureMaterial( m_iToolTargetItemTextureID, pToolTargetItemMaterial );
				}

				CAttribute_String attrToolTargetItemIconOffset;
				static CSchemaAttributeDefHandle pAttrDef_ToolTargetItemIconOffset( "tool_target_item_icon_offset" );
				if ( m_pItem->FindAttribute( pAttrDef_ToolTargetItemIconOffset, &attrToolTargetItemIconOffset ) && attrToolTargetItemIconOffset.has_value() )
				{
					UTIL_StringToVector( m_vecToolTargetItemImageOffset.Base(), attrToolTargetItemIconOffset.value().c_str() );
				}
			}

			surface()->DrawSetTexture( m_iToolTargetItemTextureID );
			
			int iStrangeX = x + ( iWidth  * m_vecToolTargetItemImageOffset.x );
			int iStrangeY = y + ( iHeight * m_vecToolTargetItemImageOffset.y );
			float flScale = m_vecToolTargetItemImageOffset.z;

			surface()->DrawTexturedSubRect( iStrangeX,
											iStrangeY,
											iStrangeX + (iWidth * flScale),
											iStrangeY + (iHeight * flScale),
											flTexX,
											flTexY,
											flTexX + (flTexW ),
											flTexY + (flTexH ) );
		}
		
		return;
	}

	item_model_cache_t *pCacheRenderTarget = NULL;
	const char *pszCacheRenderTargetName = NULL;
	// find available render target
	for ( int i=0; i<ITEM_MODEL_IMAGE_CACHE_SIZE; ++i )
	{
		CEmbeddedItemModelPanel *pLockPanel = g_ItemModelImageCache[i].m_hModelPanelLock.Get();

		// found available render target?
		if ( pLockPanel == NULL )
		{
			pszCacheRenderTargetName = m_bOfflineIconGeneration ? "offline_icon_generation" : g_ItemModelPanelRenderTargetNames[i];
			pCacheRenderTarget = &g_ItemModelImageCache[i];
			break;
		}
		else
		{
			// waiting for async copy to finish
			if ( pLockPanel->m_pCachedWeaponIcon && pLockPanel->m_pCachedWeaponIcon->GetTexture() )
			{
				g_ItemModelImageCache[i].Clear();

				pszCacheRenderTargetName = m_bOfflineIconGeneration ? "offline_icon_generation" : g_ItemModelPanelRenderTargetNames[i];
				pCacheRenderTarget = &g_ItemModelImageCache[i];
				break;
			}
		}
	}

	// can't find available cache render target, don't do anything
	if ( !pszCacheRenderTargetName || !pCacheRenderTarget )
	{
		BaseClass::Paint();
		return;
	}

	// Turn off depth-write to dest alpha so that we get white there instead.  The code that uses
	// the render target needs a mask of where stuff was rendered.
	pRenderContext->SetIntRenderingParameter( INT_RENDERPARM_WRITE_DEPTH_TO_DESTALPHA, false );

	bool bUseRenderTarget = !m_bForceUseModel && ( UseRenderTargetAsIcon() || bIsLoadingWeaponSkin );
	bool bRenderToTexture = m_bRenderToTexture;
	if ( bUseRenderTarget )
	{
		g_pMatSystemSurface->Set3DPaintTempRenderTarget( pszCacheRenderTargetName );
	}
	else if ( m_bUseParticle )
	{
		// we want to render particle with this model. don't render to texture
		m_bRenderToTexture = false;
	}

	// make sure the weapon skin is ready before we render the model
	bool bDrawWeaponWithSkin = bIsLoadingWeaponSkin && m_pCachedWeaponIcon == NULL && m_pItem->GetWeaponSkinBase();

	m_pItem->SetWeaponSkinBaseCreateFlags( TEX_COMPOSITE_CREATE_FLAGS_NO_COMPRESSION | TEX_COMPOSITE_CREATE_FLAGS_NO_MIPMAPS );

	BaseClass::Paint();

	m_bRenderToTexture = bRenderToTexture;

	// copy the rendered weapon skin from the render target
	if ( !m_bForceUseModel && ( UseRenderTargetAsIcon() || bDrawWeaponWithSkin ) && !m_pCachedWeaponIcon )
	{
		char buffer[_MAX_PATH];
		V_sprintf_safe( buffer, "proc/icon/item%d_id%lld_w%d_h%d", m_pItem->GetItemDefIndex(), m_pItem->GetID(), iWidth, iHeight );
		SafeAssign( &m_pCachedWeaponIcon, new CIconRenderReceiver() );

		// If the icon still exists in the material system, don't bother regenerating it.
		if ( materials->IsTextureLoaded( buffer ) )
		{
			ITexture* resTexture = materials->FindTexture( buffer, TEXTURE_GROUP_RUNTIME_COMPOSITE, false, 0 );
			if ( resTexture && resTexture->IsError() == false )
			{
				m_pCachedWeaponIcon->OnAsyncCreateComplete( resTexture, NULL );
			}
		}
		else
		{
			// No icon available yet, need to create it.
			ITexture *pRenderTarget = g_pMaterialSystem->FindTexture( pszCacheRenderTargetName, TEXTURE_GROUP_RENDER_TARGET );
			if ( pRenderTarget )
			{
				pRenderContext->AsyncCreateTextureFromRenderTarget( pRenderTarget, buffer, IMAGE_FORMAT_RGBA8888, false, 0, m_pCachedWeaponIcon, NULL );
			
				pCacheRenderTarget->iItemID = m_pItem->GetItemID();
				pCacheRenderTarget->iItemDefinitionIndex = m_pItem->GetItemDefIndex();
				pCacheRenderTarget->iWidth = iWidth;
				pCacheRenderTarget->iHeight = iHeight;
				pCacheRenderTarget->m_hModelPanelLock = this;
			}
		}
	}

	if ( bUseRenderTarget )
	{
		g_pMatSystemSurface->Reset3DPaintTempRenderTarget();
	}

	if ( m_flModelRotateYawSpeed != 0 )
	{
		m_angPlayer[YAW] += m_flModelRotateYawSpeed * gpGlobals->frametime;
		SetModelAnglesAndPosition( m_angPlayer, m_vecPlayerPos );
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
ITexture *CEmbeddedItemModelPanel::GetCachedGeneratedIcon() 
{ 
	return m_pCachedWeaponIcon ? m_pCachedWeaponIcon->GetTexture() : NULL;
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEmbeddedItemModelPanel::UpdateParticle(
	IMatRenderContext				*pRenderContext, 
	CStudioHdr						*pStudioHdr, 
	MDLHandle_t						mdlHandle, 
	matrix3x4_t						*pWorldMatrix
	)
{
	if ( !m_bUseParticle )
		return false;

	if ( m_pItemParticle && m_pItemParticle->m_bIsUpdateToDate )
		return false;

	if ( !m_pItem || !m_pItem->IsValid() )
		return false;

	attachedparticlesystem_t *pParticleSystem = NULL;

	// do community_sparkle effect if this is a community item?
	const int iQualityParticleType = m_pItem->GetQualityParticleType();
	if ( iQualityParticleType > 0 )
	{
		pParticleSystem = GetItemSchema()->GetAttributeControlledParticleSystem( iQualityParticleType );
	}

	if ( !pParticleSystem )
	{
		// does this hat even have a particle effect
		static CSchemaAttributeDefHandle pAttrDef_AttachParticleEffect( "attach particle effect" );
		uint32 iValue = 0;
		if ( !m_pItem->FindAttribute( pAttrDef_AttachParticleEffect, &iValue ) )
		{
			return false;
		}

		const float& value_as_float = (float&)iValue;
		pParticleSystem = GetItemSchema()->GetAttributeControlledParticleSystem( value_as_float );
	}

	// failed to find any particle effect
	if ( !pParticleSystem )
	{
		return false;
	}

	// Team Color
	if ( m_pItem->GetTeamNumber() == TF_TEAM_BLUE && V_stristr( pParticleSystem->pszSystemName, "_teamcolor_red" ))
	{
		static char pBlue[256];
		V_StrSubst( pParticleSystem->pszSystemName, "_teamcolor_red", "_teamcolor_blue", pBlue, 256 );
		pParticleSystem = GetItemSchema()->FindAttributeControlledParticleSystem( pBlue );
		if ( !pParticleSystem )
		{
			return false;
		}
	}

	// if this thing has a bip_head or prp_helmet (aka a hat)
	int iBone = Studio_BoneIndexByName( pStudioHdr, "bip_head" );
	if ( iBone < 0 )
	{
		iBone = Studio_BoneIndexByName( pStudioHdr, "prp_helmet" );
		if ( iBone < 0 )
		{
			iBone = Studio_BoneIndexByName( pStudioHdr, "prp_hat" );
		}
	}
	
	// default to root
	if ( iBone < 0 ) 
	{
		iBone = 0;
	}

	// Get Use Head Origin
	CUtlVector< int > vecAttachments;
	static CSchemaAttributeDefHandle pAttrDef_UseHead( "particle effect use head origin" );
	uint32 iUseHead = 0;
	if ( !m_pItem->FindAttribute( pAttrDef_UseHead, &iUseHead ) || !iUseHead == 0 )
	{
		// not using head? try searching for attachment points
		for ( int i=0; i<ARRAYSIZE( pParticleSystem->pszControlPoints ); ++i )
		{
			const char *pszAttachmentName = pParticleSystem->pszControlPoints[i];
			if ( pszAttachmentName && pszAttachmentName[0] )
			{
				int iAttachment = Studio_FindAttachment( pStudioHdr, pszAttachmentName );
				if ( iAttachment < 0 )
					continue;

				vecAttachments.AddToTail( iAttachment );
			}
		}
	}

	static char pszFullname[256];
	const char* pszSystemName = pParticleSystem->pszSystemName;
	// Weapon Remap for a Base Effect to be used on a specific weapon
	if ( pParticleSystem->bUseSuffixName && m_pItem && m_pItem->GetItemDefinition()->GetParticleSuffix() )
	{
		V_strcpy_safe( pszFullname, pParticleSystem->pszSystemName );
		V_strcat_safe( pszFullname, "_" );
		V_strcat_safe( pszFullname, m_pItem->GetItemDefinition()->GetParticleSuffix() );
		pszSystemName = pszFullname;
	}

	// Update the Particles and render them
	if ( m_pItemParticle )
	{
		// Check if its a new particle system
		if ( V_strcmp( m_pItemParticle->m_pParticleSystem->GetName(), pszSystemName ) )
		{
			SafeDeleteParticleData( &m_pItemParticle );
			m_pItemParticle = CreateParticleData( pszSystemName );
		}
	}
	else
	{
		// create
		m_pItemParticle = CreateParticleData( pszSystemName );
	}

	// Particle system does not exist
	if ( !m_pItemParticle )
		return false;

	// Get offset if it exists (and if we're using head offset)
	static CSchemaAttributeDefHandle pAttrDef_VerticalOffset( "particle effect vertical offset" );
	uint32 iOffset = 0;
	Vector vecParticleOffset( 0, 0, 0 );
	if ( iUseHead > 0 && m_pItem->FindAttribute( pAttrDef_VerticalOffset, &iOffset ) )
	{
		vecParticleOffset.z = (float&)iOffset;
	}

	m_pItemParticle->UpdateControlPoints( pStudioHdr, pWorldMatrix, vecAttachments, 0, vecParticleOffset );
	return true;
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEmbeddedItemModelPanel::RenderStatTrack( CStudioHdr *pStudioHdr, matrix3x4_t *pWorldMatrix )
{
	// Draw the merge MDLs.
	if ( !m_StatTrackModel.m_bDisabled )
	{
		matrix3x4_t matMergeBoneToWorld[MAXSTUDIOBONES];

		// Get the merge studio header.
		studiohdr_t *pStatTrackStudioHdr = m_StatTrackModel.m_MDL.GetStudioHdr();
		matrix3x4_t *pMergeBoneToWorld = &matMergeBoneToWorld[0];

		// If we have a valid mesh, bonemerge it. If we have an invalid mesh we can't bonemerge because
		// it'll crash trying to pull data from the missing header.
		if ( pStatTrackStudioHdr != NULL )
		{
			CStudioHdr mergeHdr( pStatTrackStudioHdr, g_pMDLCache );
			m_StatTrackModel.m_MDL.SetupBonesWithBoneMerge( &mergeHdr, pMergeBoneToWorld, pStudioHdr, pWorldMatrix, m_StatTrackModel.m_MDLToWorld );
			for ( int i=0; i<mergeHdr.numbones(); ++i )
			{
				MatrixScaleBy( m_flStatTrackScale, pMergeBoneToWorld[i] );
			}
			m_StatTrackModel.m_MDL.Draw( m_StatTrackModel.m_MDLToWorld, pMergeBoneToWorld );
		}

		return true;
	}

	return false;
}

bool CEmbeddedItemModelPanel::RenderAttachedModels( CStudioHdr *pStudioHdr, matrix3x4_t *pWorldMatrix )
{
	// Draw the merge MDLs.
	FOR_EACH_VEC( m_AttachedModels, iModel )
	{
		matrix3x4_t matMergeBoneToWorld[MAXSTUDIOBONES];

		// Get the merge studio header.
		studiohdr_t *pAttachedStudioHdr = m_AttachedModels[iModel].m_MDL.GetStudioHdr();
		matrix3x4_t *pMergeBoneToWorld = &matMergeBoneToWorld[0];

		// If we have a valid mesh, bonemerge it. If we have an invalid mesh we can't bonemerge because
		// it'll crash trying to pull data from the missing header.
		if ( pAttachedStudioHdr != NULL )
		{
			CStudioHdr mergeHdr( pAttachedStudioHdr, g_pMDLCache );
			m_AttachedModels[iModel].m_MDL.SetupBonesWithBoneMerge( &mergeHdr, pMergeBoneToWorld, pStudioHdr, pWorldMatrix, m_AttachedModels[iModel].m_MDLToWorld );
			m_AttachedModels[iModel].m_MDL.Draw( m_AttachedModels[iModel].m_MDLToWorld, pMergeBoneToWorld );
		}
	}
	return true;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEmbeddedItemModelPanel::RenderingRootModel( IMatRenderContext *pRenderContext, CStudioHdr *pStudioHdr, MDLHandle_t mdlHandle, matrix3x4_t *pWorldMatrix )
{
	// No model?  Bail
	if ( m_ItemModel.m_bDisabled )
	{
		// no model means not using pedestal. just use pStudioHdr to find the attachment points
		UpdateParticle( pRenderContext, pStudioHdr, mdlHandle, pWorldMatrix );
		RenderStatTrack( pStudioHdr, pWorldMatrix );
		RenderAttachedModels( pStudioHdr, pWorldMatrix );
		return;
	}

	studiohdr_t *pItemStudioHdr = m_ItemModel.m_MDL.GetStudioHdr();
	
	if ( pItemStudioHdr != NULL )
	{
		matrix3x4_t matIdentity;
		SetIdentityMatrix( matIdentity );

		matrix3x4_t *pBoneToWorld = g_pStudioRender->LockBoneMatrices( pItemStudioHdr->numbones );
		m_ItemModel.m_MDL.SetUpBones( matIdentity, pItemStudioHdr->numbones, pBoneToWorld );

		// Get attachment transform
		mstudioattachment_t attach = pItemStudioHdr->pAttachment( m_iPedestalAttachment );
		matrix3x4_t matLocalToWorld;
		matrix3x4_t matWorldToLocal;
		matrix3x4_t matTransform;

		ConcatTransforms( pBoneToWorld[ attach.localbone ], attach.local, matLocalToWorld );
		MatrixInvert( matLocalToWorld, matWorldToLocal );
		ConcatTransforms( m_RootMDL.m_MDLToWorld, matWorldToLocal, matTransform );

		m_ItemModel.m_MDL.SetUpBones( matTransform, pItemStudioHdr->numbones, pBoneToWorld );

		g_pStudioRender->UnlockBoneMatrices();

		IMaterial* pOverrideMaterial = GetOverrideMaterial( m_ItemModel.m_MDL.GetMDL() );
		if ( pOverrideMaterial != NULL )
			g_pStudioRender->ForcedMaterialOverride( pOverrideMaterial );

		m_ItemModel.m_MDL.Draw( m_ItemModel.m_MDLToWorld, pBoneToWorld );

		if ( pOverrideMaterial != NULL )
			g_pStudioRender->ForcedMaterialOverride( NULL );

		CStudioHdr HDR( pItemStudioHdr, g_pMDLCache );

		// update particle with the actual item model pItemStudioHdr
		UpdateParticle( pRenderContext, &HDR, mdlHandle, pBoneToWorld );
		RenderStatTrack( &HDR, pBoneToWorld );
		RenderAttachedModels( &HDR, pBoneToWorld );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IMaterial *CEmbeddedItemModelPanel::GetOverrideMaterial( MDLHandle_t mdlHandle )
{
	// This matches the check in RenderingRootModel, if we're not on a pedestal
	// then we expect mdlHandle to not match m_ItemModel and that's fine--we should
	// just get the override from the m_pItem
	if ( !m_ItemModel.m_bDisabled && m_ItemModel.m_MDL.GetMDL() != mdlHandle )
		return NULL;

	if ( !m_pItem ) 
		return NULL;

	int iTeam = GetLocalPlayerTeam();

#ifdef TF_CLIENT_DLL
	// If we aren't in a game we default to previewing the red team skin.
	if ( iTeam == TEAM_UNASSIGNED )
	{
		iTeam = TF_TEAM_RED;
	}
#endif

	return m_pItem->GetMaterialOverride( iTeam );
}


float CItemModelPanel::sm_flLoadingTimeThisFrame = 0.0f;
int   CItemModelPanel::sm_nCurrentDecriptionUpdateFrame = 0;
CItemModelPanel::eLoadingType_t CItemModelPanel::se_CurrentLoadingTask = LOADING_ICONS;
int CItemModelPanel::sai_NumLoadingRequests[NUM_LOADING_TYPES] = {0,0,0};
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CItemModelPanel::CItemModelPanel( vgui::Panel *parent, const char *name ) : vgui::EditablePanel( parent, name )
{
	m_pModelPanel = NULL;
	m_pItemNameLabel = NULL;
	m_pPaintIcon = NULL;
	m_pTF2Icon = NULL;
	m_pItemAttribLabel = NULL;
	m_pItemCollectionNameLabel = NULL;
	m_pItemCollectionListLabel = NULL;
	m_pItemCollectionHighlight = NULL;
	m_pItemEquippedLabel = NULL;
	m_pItemQuantityLabel = NULL;
	m_pVisionRestrictionImage = NULL;
	m_pIsStrangeImage = NULL;
	m_pIsUnusualImage = NULL;
	m_pIsLoanerImage = NULL;
	m_pSeriesLabel = NULL;
	m_pMainContentContainer = NULL;
	m_pLoadingSpinner = NULL;
//	m_ItemData = NULL;
	m_nCollectionItemLoaded = LOADED_COLLECTION_NONE;
	m_pFontNameSmallest = vgui::INVALID_FONT;
	m_pFontNameSmall = vgui::INVALID_FONT;
	m_pFontNameLarge = vgui::INVALID_FONT;
	m_pFontAttribSmallest = vgui::INVALID_FONT;
	m_pFontAttribSmall = vgui::INVALID_FONT;
	m_pFontAttribLarge = vgui::INVALID_FONT;

	m_pszNoItemText = NULL;
	m_pwcNoItemText = NULL;
	m_pwcNoItemAttrib = NULL;
	REGISTER_COLOR_AS_OVERRIDABLE( m_NoItemTextColor, "noitem_textcolor" );

	m_bClickable = false;
	m_bMouseOver = false;
	m_bSelected = false;
	m_bShowEquipped = false;
	m_bForceShowEquipped = false;
	m_bShowQuantity = false;
	m_pszGreyedOutReason = NULL;
	m_bShowGreyedOutTooltip = false;
	m_bShouldSendPanelEnterExits = false;
	m_bContainedItem = false;
	m_bShowOthersGiftWrappedItems = false;
	m_bDescriptionDirty = false;
	m_nRecipeMatchingIndex = 0;

	m_pContainedItemPanel = NULL;

	m_bFakeButton = false;

	m_mapMatchingAttributes.SetLessFunc( DefLessFunc( attrib_definition_index_t ) );

	SetActAsButton( false, false );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CItemModelPanel::~CItemModelPanel( void )
{
	CleanupNoItemWChars();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::ApplySchemeSettings( vgui::IScheme *pScheme )
{
	BaseClass::ApplySchemeSettings( pScheme );
	// These pointers must be zeroed here because their memory may be freed
	// by LoadControlSettings *and* if they remain non-zero they may be dereferenced
	// before LoadControlSettings returns. This causes reliable crashes if you
	// go to the store, shop, change resolutions, then return to the store -- and
	// if you use pageheap/AppVerifier.
	// This set of pointers is simply the set of pointers that are initialized after
	// LoadControlSettings.
	m_pModelPanel = NULL;
	m_pItemNameLabel = NULL;
	m_pItemAttribLabel = NULL;
	m_pItemCollectionNameLabel = NULL;
	m_pItemCollectionListLabel = NULL;
	m_pItemEquippedLabel = NULL;
	m_pItemQuantityLabel = NULL;
	m_pVisionRestrictionImage = NULL;
	m_pIsStrangeImage = NULL;
	m_pIsUnusualImage = NULL;
	m_pIsLoanerImage = NULL;
	m_pSeriesLabel = NULL;
	m_pMatchesLabel = NULL;
	m_pPaintIcon = NULL;
	m_pTF2Icon = NULL;
	m_pFontNameSmallest = NULL;
	m_pFontNameSmall = NULL;
	m_pFontNameLarge = NULL;
	m_pFontNameLarger = NULL;
	m_pFontAttribSmallest = NULL;
	m_pFontAttribSmall = NULL;
	m_pFontAttribLarge = NULL;
	m_pFontAttribLarger = NULL;
	m_pContainedItemPanel = NULL;
	m_pMainContentContainer = NULL;
	m_pLoadingSpinner = NULL;
	m_nCollectionItemLoaded = LOADED_COLLECTION_NONE;
	LoadResFileForCurrentItem( true );

	m_pFontNameSmallest = pScheme->GetFont( "ItemFontNameSmallest", true );
	m_pFontNameSmall = pScheme->GetFont( "ItemFontNameSmall", true );
	m_pFontNameLarge = pScheme->GetFont( "ItemFontNameLarge", true );
	m_pFontNameLarger = pScheme->GetFont( "ItemFontNameLarger", true );
	m_pFontAttribSmallest = pScheme->GetFont( "ItemFontAttribSmallest", true );
	m_pFontAttribSmall = pScheme->GetFont( "ItemFontAttribSmallv2", true );
	m_pFontAttribLarge = pScheme->GetFont( "ItemFontAttribLarge", true );
	m_pFontAttribLarger = pScheme->GetFont( "ItemFontAttribLarger", true );

	if ( m_bContainedItem )
	{
		// SetBorder( pScheme->GetBorder("TFThinLineBorder") );
	}
	else
	{
		SetBorder( pScheme->GetBorder( "TFFatLineBorder" ) );
	}

	if ( m_pModelPanel )
	{
		m_pModelPanel->SetBorder( pScheme->GetBorder( "TFFatLineBorder" ) );
	}
}

void CItemModelPanel::ApplySettings( KeyValues *inResourceData )
{
	if ( !inResourceData )
		return;

	BaseClass::ApplySettings( inResourceData );

	// Pass the itemmodelpanel KVs to the actual model panel
	KeyValues* pItemModelPanelKVs = inResourceData->FindKey( "itemmodelpanel" );
	if ( m_pModelPanel && pItemModelPanelKVs )
	{
		m_pModelPanel->ApplySettings( pItemModelPanelKVs );
	}

	// We can get our settings applied AFTER we've already setup our
	// panel, so re-update.
	UpdatePanels();
}

void CItemModelPanel::LoadResFileForCurrentItem( bool bForceLoad )
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
	bool bCollectionMouseover = ( m_bIsMouseOverPanel && GetItem() && GetItem()->GetItemDefinition()->GetItemCollectionDefinition() );
	if ( bCollectionMouseover )
	{
		float flInspect = 0;
		static CSchemaAttributeDefHandle pAttrib_WeaponAllowInspect( "weapon_allow_inspect" );
		if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( GetItem(), pAttrib_WeaponAllowInspect, &flInspect ) && flInspect != 0.f )
		{
			if ( bForceLoad || m_nCollectionItemLoaded != LOADED_COLLECTION_WEAPON )
			{
				tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s ItemModelPanelCollectionItem", __FUNCTION__ );
				LoadControlSettings( "Resource/UI/econ/ItemModelPanelCollectionItem.res" );
				m_nCollectionItemLoaded = LOADED_COLLECTION_WEAPON;
			}
		}
		else
		{
			if ( bForceLoad || m_nCollectionItemLoaded != LOADED_COLLECTION_COSMETIC )
			{
				tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s ItemModelPanelCollectionCosmeticItem", __FUNCTION__ );
				LoadControlSettings( "Resource/UI/econ/ItemModelPanelCollectionCosmeticItem.res" );
				m_nCollectionItemLoaded = LOADED_COLLECTION_COSMETIC;
			}
		}
		m_bHideModel = false; // Hack
	}
	else
	{
		if ( bForceLoad || m_nCollectionItemLoaded != LOADED_COLLECTION_NONE )
		{
			tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s ItemModelPanel", __FUNCTION__ );
			LoadControlSettings( "Resource/UI/econ/ItemModelPanel.res" );
		}
		m_bHideModel = m_bHideModelDefault;
		m_nCollectionItemLoaded = LOADED_COLLECTION_NONE;
	}
	
	m_pModelPanel = dynamic_cast<CEmbeddedItemModelPanel*>( FindChildByName( "itemmodelpanel", true ) );
	SetModelIsHidden( m_bHideModel );
	if ( m_bIsMouseOverPanel && m_pModelPanel )
	{
		m_pModelPanel->SetInventoryImageType( CEmbeddedItemModelPanel::IMAGETYPE_LARGE );
	}

	m_pItemNameLabel = dynamic_cast<CExLabel*>( FindChildByName( "namelabel", true ) );
	m_pItemAttribLabel = dynamic_cast<vgui::Label*>( FindChildByName( "attriblabel", true ) );
	m_pItemCollectionNameLabel = dynamic_cast<CExLabel*>( FindChildByName( "collectionnamelabel", true ) );
	m_pItemCollectionListLabel = dynamic_cast<vgui::Label*>( FindChildByName( "collectionlistlabel", true ) );
	m_pItemCollectionHighlight = dynamic_cast<vgui::EditablePanel*>( FindChildByName( "collectionhighlight", true ) );
	m_pItemEquippedLabel = dynamic_cast<vgui::Label*>( FindChildByName( "equippedlabel", true ) );
	m_pItemQuantityLabel = dynamic_cast<vgui::Label*>( FindChildByName( "quantitylabel", true ) );
	m_pVisionRestrictionImage = dynamic_cast<vgui::ImagePanel*>( FindChildByName( "vision_restriction_icon", true ) );

	m_pIsStrangeImage = dynamic_cast<vgui::ImagePanel*>( FindChildByName( "is_strange_icon", true ) );
	m_pIsUnusualImage = dynamic_cast<vgui::ImagePanel*>( FindChildByName( "is_unusual_icon", true ) );
	m_pIsLoanerImage = dynamic_cast<vgui::ImagePanel*>( FindChildByName( "is_loaner_icon", true ) );

	m_pSeriesLabel = dynamic_cast<vgui::Label*>( FindChildByName( "serieslabel", true ) );
	m_pMatchesLabel = dynamic_cast<vgui::Label*>( FindChildByName( "matcheslabel", true ) );
	m_pMainContentContainer = dynamic_cast<vgui::EditablePanel*>( FindChildByName( "MainContentsContainer" ) );
	m_pLoadingSpinner = dynamic_cast<vgui::ImagePanel*>( FindChildByName( "LoadingSpinner" ) );

	if ( m_pItemEquippedLabel )
	{
		m_pItemEquippedLabel->SetKeyBoardInputEnabled( false );
		m_pItemEquippedLabel->SetMouseInputEnabled( false );
	}
	if ( m_pItemQuantityLabel )
	{
		m_pItemQuantityLabel->SetKeyBoardInputEnabled( false );
		m_pItemQuantityLabel->SetMouseInputEnabled( false );
	}
	if ( m_pVisionRestrictionImage )
	{
		m_pVisionRestrictionImage->SetKeyBoardInputEnabled( false );
		m_pVisionRestrictionImage->SetMouseInputEnabled( false );
	}
	if ( m_pIsStrangeImage )
	{
		m_pIsStrangeImage->SetKeyBoardInputEnabled( false );
		m_pIsStrangeImage->SetMouseInputEnabled( false );
	}
	if ( m_pIsUnusualImage )
	{
		m_pIsUnusualImage->SetKeyBoardInputEnabled( false );
		m_pIsUnusualImage->SetMouseInputEnabled( false );
	}
	if ( m_pIsLoanerImage )
	{
		m_pIsLoanerImage->SetKeyBoardInputEnabled( false );
		m_pIsLoanerImage->SetMouseInputEnabled( false );
	}

	if ( m_pSeriesLabel )
	{
		m_pSeriesLabel->SetKeyBoardInputEnabled( false );
		m_pSeriesLabel->SetMouseInputEnabled( false );
	}
	if ( m_pMatchesLabel )
	{
		m_pMatchesLabel->SetKeyBoardInputEnabled( false );
		m_pMatchesLabel->SetMouseInputEnabled( false );
	}

	m_pPaintIcon = dynamic_cast<CItemMaterialCustomizationIconPanel*>( FindChildByName( "paint_icon", true ) );
	if ( m_pPaintIcon )
	{
		m_pPaintIcon->SetMouseInputEnabled( false );
	}
	m_pTF2Icon = dynamic_cast<vgui::ScalableImagePanel*>( FindChildByName( "tf2_icon", true ) );
	if ( m_pTF2Icon )
	{
		m_pTF2Icon->SetMouseInputEnabled( false );
	}

	if ( m_bContainedItem )
	{
		SetPaintBackgroundEnabled( true );
	}
	else
	{
		SetPaintBackgroundEnabled( false );
	}

	if ( m_pModelPanel )
	{
		m_pModelPanel->SetBgColor( Color( 0, 0, 0, 255 ) );
		m_pModelPanel->AddActionSignalTarget( this );
		m_pModelPanel->SetMouseInputEnabled( false );
	}

	if ( m_pItemNameLabel )
	{
		m_OrgItemTextColor = m_pItemNameLabel->GetFgColor();
		m_pItemNameLabel->SetMouseInputEnabled( false );
		m_pItemNameLabel->AddActionSignalTarget( this );
		m_pItemNameLabel->InvalidateLayout( true, true );
	}

	if ( m_pItemAttribLabel )
	{
		m_pItemAttribLabel->SetMouseInputEnabled( false );
		m_pItemAttribLabel->AddActionSignalTarget( this );
		m_pItemAttribLabel->InvalidateLayout( true, true );
	}

	if ( m_pItemCollectionNameLabel )
	{
		m_pItemCollectionNameLabel->SetMouseInputEnabled( false );
		m_pItemCollectionNameLabel->AddActionSignalTarget( this );
		m_pItemCollectionNameLabel->InvalidateLayout( true, true );
	}

	if ( m_pItemCollectionListLabel )
	{
		m_pItemCollectionListLabel->SetMouseInputEnabled( false );
		m_pItemCollectionListLabel->AddActionSignalTarget( this );
		m_pItemCollectionListLabel->InvalidateLayout( true, true );
	}

	if ( m_pItemCollectionHighlight )
	{
		m_pItemCollectionHighlight->SetMouseInputEnabled( false );
		m_pItemCollectionHighlight->AddActionSignalTarget( this );
		m_pItemCollectionHighlight->InvalidateLayout( true, true );
	}

	m_pContainedItemPanel = dynamic_cast<CItemModelPanel*>( FindChildByName( "contained_item_panel", true ) );

	// Dont eat mouse input
	if ( m_pMainContentContainer )
	{
		m_pMainContentContainer->SetMouseInputEnabled( false );
	}

	UpdatePanels();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::PerformLayout( void ) 
{
	int w,h;
	GetSize( w, h );
	w = m_iBaseWide ? m_iBaseWide : w;
	h = m_iBaseTall ? m_iBaseTall : h;

	int iTextW = GetAttribWide(w);
	int iModelW = m_iModelWide && m_iModelWide < w ? m_iModelWide : w;
	int iModelT = m_iModelTall && m_iModelTall < h ? m_iModelTall : h;
	int iModelX = m_bModelCenterX ? ( ( w - iModelW ) * 0.5 ) : m_iModelXPos;
	int iModelY = m_bModelCenterY ? ( ( h - iModelT ) * 0.5 ) : m_iModelYPos;

	ResizeLabels();

	if ( m_pModelPanel )
	{
		m_pModelPanel->SetBounds( iModelX, iModelY, iModelW, iModelT );
	}
	if ( m_pLoadingSpinner )
	{
		int nWidthHeight = Max( iModelW, iModelT );
		int xOffset = int( w / 2.f ) - int( nWidthHeight / 2.f );
		int yOffset = int( h / 2.f ) - int( nWidthHeight / 2.f );
		m_pLoadingSpinner->SetBounds( xOffset, yOffset, nWidthHeight, nWidthHeight );
	}

	if ( m_bNoItemFullPanel )
	{
		// We want the "no item" text to use the entire panel, and hide the attribs entirely
		if ( m_pItemNameLabel && m_pItemAttribLabel )
		{
			m_pItemNameLabel->SetBounds( XRES(4), 0, GetWide() - XRES(8), GetTall() );
		}
	}
	else if ( m_pItemNameLabel && m_pItemAttribLabel && !m_bModelOnly )
	{
		// Force the labels to layout now, and get their height.
		m_pItemNameLabel->InvalidateLayout( true );
		m_pItemAttribLabel->InvalidateLayout( true );
		m_pItemNameLabel->SizeToContents();
		m_pItemAttribLabel->SizeToContents();

		if ( m_pItemCollectionNameLabel )
		{
			m_pItemCollectionNameLabel->InvalidateLayout( true );
			m_pItemCollectionNameLabel->SizeToContents();
		}
			
		if ( m_pItemCollectionListLabel )
		{
			m_pItemCollectionListLabel->InvalidateLayout( true );
			m_pItemCollectionListLabel->SizeToContents();
		}

		// "" strings still size themselves as one font-heighth tall, but 0 wide. If there's no
		// text in the attribute, we want 0 tall as well, so we don't get blank lines.
		int iCollectionTall = m_pItemCollectionListLabel ? m_pItemCollectionListLabel->GetTall() : 0;
		int iAttribTall = (m_pItemAttribLabel->GetWide() ? m_pItemAttribLabel->GetTall() : 0);
		iAttribTall = Max( iAttribTall, iCollectionTall );

		int iNameTall = m_pItemNameLabel->GetTall();

		int iCollectionNameTall = m_pItemCollectionNameLabel ? m_pItemCollectionNameLabel->GetTall() : 0;

		if ( m_bAttribOnly )
		{
			iNameTall = 0;
		}

		if ( m_bTextCenterX )
		{
			m_pItemNameLabel->SetSize( iTextW, iNameTall );
			m_pItemAttribLabel->SetSize( iTextW, iAttribTall );
		}
		else if ( m_iTextYPos )
		{
			m_pItemNameLabel->SetSize( iTextW, iNameTall );
			m_pItemAttribLabel->SetSize( iTextW, (m_pItemAttribLabel->GetWide() ? m_pItemAttribLabel->GetTall() : 0) );
			if ( m_pItemCollectionNameLabel )
				m_pItemCollectionNameLabel->SetSize( iTextW, iCollectionNameTall );
			if ( m_pItemCollectionListLabel )
				m_pItemCollectionListLabel->SetSize( iTextW, iCollectionTall );
		}
		else if ( m_bTextCenter )
		{
			m_pItemNameLabel->SetSize( iTextW, iNameTall );
			m_pItemAttribLabel->SetSize( iTextW, iAttribTall );
		}
		else
		{
			m_pItemNameLabel->SetSize( iTextW, iNameTall );
			m_pItemAttribLabel->SetSize( iTextW, iAttribTall );
		}

		m_pItemNameLabel->InvalidateLayout( true );

		// Force attrib layout to update now in its new size.
		m_pItemAttribLabel->InvalidateLayout( true );
		m_pItemAttribLabel->SizeToContents();
		
		// Reget sizes, wtf
		iCollectionTall = m_pItemCollectionListLabel ? m_pItemCollectionListLabel->GetTall() : 0;
		iAttribTall = ( m_pItemAttribLabel->GetWide() ? m_pItemAttribLabel->GetTall() : 0 );
		// HACK: Now we resize it again. Sets our height properly. Ridiculous. 
		m_pItemAttribLabel->SetSize( iTextW, iAttribTall );
		m_pItemNameLabel->SetSize( iTextW, iNameTall );

		// Ignore attributes if we're only showing the name
		if ( m_bNameOnly || (!HasItem() && m_pszNoItemText && m_pszNoItemText[0]) )
		{
			iAttribTall = 0;
		}

		int iLabelOffset = 0;
		if ( m_bResizeToText )
		{
			h = m_iTextYPos + iNameTall + iAttribTall + m_iHPadding;

			// Must be at least tall enough to fit the image (if visible)
			if ( !m_bHideModel )
			{
				//h = MAX( h, (iModelT + (iModelY * 2)) );
				h = Max( h + iModelT + iModelY, m_iTextYPos + iCollectionNameTall + iCollectionTall + m_iHPadding);
				iLabelOffset = iModelT + iModelY;
			}
		}

		// If we don't have a specific X pos, or attrib width, indent ourselves
		int iTextXPos = (m_iTextXPos || m_iTextWide) ? m_iTextXPos : ATTRIB_LABEL_INDENT;

		if ( iCollectionNameTall && iCollectionTall && m_iTextXPosCollection )
		{
			iTextXPos = m_iTextXPosCollection;
		}

		// Position the name label now we know where our attrib label is
		// If we've got a Y pos, use it. Otherwise, stack up from the bottom of the panel.
		if ( m_bTextCenterX )
		{
			m_pItemNameLabel->SizeToContents();
			m_pItemAttribLabel->SizeToContents();

			m_pItemNameLabel->SetPos( ( w - m_pItemNameLabel->GetWide() ) * 0.5f, m_iTextYPos + iLabelOffset );
			m_pItemAttribLabel->SetPos( ( w - m_pItemAttribLabel->GetWide() ) * 0.5f, m_iTextYPos + iNameTall + iLabelOffset );
		}
		else if ( m_iTextYPos )
		{
			m_pItemNameLabel->SetPos( iTextXPos, m_iTextYPos + iLabelOffset );
			m_pItemAttribLabel->SetPos( iTextXPos, m_iTextYPos + iNameTall + iLabelOffset);
			if ( m_pItemCollectionNameLabel )
				m_pItemCollectionNameLabel->SetPos( m_iCollectionListXPos, m_iTextYPos );
			if ( m_pItemCollectionListLabel )
				m_pItemCollectionListLabel->SetPos( m_iCollectionListXPos, m_iTextYPos + iCollectionNameTall );
		}
		else if ( m_bTextCenter )
		{
			int iYTop = (h - (iNameTall + iAttribTall)) * 0.5;
			if ( iYTop < 0 )
			{
				iYTop = 0;
			}
			m_pItemNameLabel->SetPos( iTextXPos, iYTop );
			m_pItemAttribLabel->SetPos( iTextXPos, iYTop + iNameTall );
			//m_pItemCollectionLabel->SetPos( iTextXPos + iTextW, iYTop );
		}
		else
		{
			int iOffsetY = (m_iTextYOffset != 0) ? m_iTextYOffset : YRES(8);
			m_pItemNameLabel->SetPos( iTextXPos, h - iAttribTall - iNameTall - iOffsetY + m_iHPadding );
			m_pItemAttribLabel->SetPos( iTextXPos, h - iAttribTall - iOffsetY + m_iHPadding );
			//m_pItemCollectionLabel->SetPos( iTextXPos + iTextW, h - iAttribTall - iNameTall - iOffsetY + m_iHPadding );
		}

		if ( m_bResizeToText )
		{
			if ( m_bIsMouseOverPanel && GetItem() && GetItem()->GetItemDefinition()->GetItemCollectionDefinition() && !m_bHideCollectionPanel )
			{
				if ( m_pItemCollectionListLabel && m_pItemCollectionNameLabel && m_pItemCollectionHighlight )
				{
					m_pItemCollectionListLabel->SizeToContents();
					m_pItemCollectionNameLabel->SizeToContents();
					int iContentW = Max( m_pItemCollectionNameLabel->GetWide(), m_pItemCollectionListLabel->GetWide() );
					w = iContentW + m_iCollectionListXPos + m_iTextXPosCollection;
					m_pItemCollectionHighlight->SetWide( iContentW );
				}
			}
			SetSize( w, h );
		}
	}

	// pin icons to top right corner
	int xpos = m_iBaseWide - XRES(1);
	int ypos = YRES(1);

	if ( m_pPaintIcon && m_pPaintIcon->IsVisible() )
	{
		m_pPaintIcon->SetPos( xpos - m_pPaintIcon->GetWide(), ypos );
		ypos += m_pPaintIcon->GetTall() * 0.9;
	}
	if ( m_pTF2Icon && m_pTF2Icon->IsVisible() )
	{
		m_pTF2Icon->SetPos( xpos - m_pTF2Icon->GetWide() + m_iTF2IconOffsetX, ypos + m_iTF2IconOffsetY );
		ypos += m_pTF2Icon->GetTall() * 0.9;
	}
	if ( m_pVisionRestrictionImage && m_pVisionRestrictionImage->IsVisible() )
	{
		m_pVisionRestrictionImage->SetPos( xpos - m_pVisionRestrictionImage->GetWide(), ypos );
		ypos += m_pVisionRestrictionImage->GetTall() * 0.9;
	}
	if ( m_pIsUnusualImage && m_pIsUnusualImage->IsVisible() )
	{
		m_pIsUnusualImage->SetPos( xpos - m_pIsUnusualImage->GetWide(), ypos );
		ypos += m_pIsUnusualImage->GetTall() * 0.9;
	}
	if ( m_pIsStrangeImage && m_pIsStrangeImage->IsVisible() )
	{
		m_pIsStrangeImage->SetPos( xpos - m_pIsStrangeImage->GetWide(), ypos );
		ypos += m_pIsStrangeImage->GetTall() * 0.9;
	}
	if ( m_pIsLoanerImage && m_pIsLoanerImage->IsVisible() )
	{
		m_pIsLoanerImage->SetPos( xpos - m_pIsLoanerImage->GetWide(), ypos );
		ypos += m_pIsLoanerImage->GetTall() * 0.9;
	}
	

	if ( m_pItemNameLabel )
	{
		//m_pItemNameLabel->SetContentAlignment( (vgui::Label::Alignment) m_iNameLabelAlignment );
	}

	if ( m_bModelOnly )
	{
		if ( m_pItemNameLabel )
		{
			m_pItemNameLabel->SetVisible( false );
		}
		if ( m_pItemAttribLabel )
		{
			m_pItemAttribLabel->SetVisible( false );
		}
		if ( m_pItemCollectionNameLabel )
		{
			m_pItemCollectionNameLabel->SetVisible( false );
		}
		if ( m_pItemCollectionListLabel )
		{
			m_pItemCollectionListLabel->SetVisible( false );
		}
		if ( m_pItemCollectionHighlight )
		{
			m_pItemCollectionHighlight->SetVisible( false );
		}
	}

	BaseClass::PerformLayout();
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::PaintTraverse( bool forceRepaint, bool allowForce )
{
	if ( m_bFakeButton )
		return;
	
	BaseClass::PaintTraverse( forceRepaint, allowForce );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::OnSizeChanged( int newWide, int newTall )
{
	BaseClass::OnSizeChanged( newWide, newTall );
	InvalidateLayout( true );

	if ( m_bModelOnly )
		return;

	if ( m_pItemNameLabel && m_pItemNameLabel->GetTextImage() )
	{
		m_pItemNameLabel->GetTextImage()->RecalculateNewLinePositions();
	}
	if ( m_pItemAttribLabel && m_pItemAttribLabel->GetTextImage() )
	{
		m_pItemAttribLabel->GetTextImage()->RecalculateNewLinePositions();
	}
	if ( m_pItemCollectionNameLabel && m_pItemCollectionNameLabel->GetTextImage() )
	{
		m_pItemCollectionNameLabel->GetTextImage()->RecalculateNewLinePositions();
	}
	if ( m_pItemCollectionListLabel && m_pItemCollectionListLabel->GetTextImage() )
	{
		m_pItemCollectionListLabel->GetTextImage()->RecalculateNewLinePositions();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::ResizeLabels( void )
{
	if ( !m_pItemNameLabel || !m_pItemAttribLabel || m_bModelOnly )
		return;

	int w,h;
	GetSize( w, h );
	int iTextW = GetAttribWide(w);

	if ( m_iMaxTextHeight )
	{
		h = m_iMaxTextHeight;
	}

	// HACK to get the item model panel on the main menu to have its fonts.
	vgui::IScheme *pScheme = scheme()->GetIScheme( GetScheme() );
	if ( !m_pFontNameSmallest )
		m_pFontNameSmallest = pScheme->GetFont( "ItemFontNameSmallest", true );
	if ( !m_pFontNameSmall )
		m_pFontNameSmall = pScheme->GetFont( "ItemFontNameSmall", true );
	if ( !m_pFontNameLarge )
		m_pFontNameLarge = pScheme->GetFont( "ItemFontNameLarge", true );
	if ( !m_pFontNameLarger )
		m_pFontNameLarger = pScheme->GetFont( "ItemFontNameLarger", true );
	if ( !m_pFontAttribSmallest )
		m_pFontAttribSmallest = pScheme->GetFont( "ItemFontAttribSmallest", true );
	if ( !m_pFontAttribSmall )
		m_pFontAttribSmall = pScheme->GetFont( "ItemFontAttribSmallv2", true );
	if ( !m_pFontAttribLarge )
		m_pFontAttribLarge = pScheme->GetFont( "ItemFontAttribLarge", true );
	if ( !m_pFontAttribLarger )
		m_pFontAttribLarger = pScheme->GetFont( "ItemFontAttribLarger", true );

	if ( m_iForceTextSize && m_iForceTextSize <= 4 )
	{
		// Leave center wrap on if the noitem text is getting to use the whole panel
		if ( !m_bNoItemFullPanel )
		{
			m_pItemNameLabel->SetCenterWrap( false );
		}
		m_pItemNameLabel->InvalidateLayout( true, true );
		m_pItemAttribLabel->InvalidateLayout( true, true );
		if ( m_pItemCollectionNameLabel )
			m_pItemCollectionNameLabel->InvalidateLayout( true, true );
		if ( m_pItemCollectionListLabel )
			m_pItemCollectionListLabel->InvalidateLayout( true, true );

		switch ( m_iForceTextSize )
		{
		case 1:
			m_pItemNameLabel->SetFont( m_pFontNameLarge );
			m_pItemAttribLabel->SetFont( m_pFontAttribLarge );
			if ( m_pItemCollectionNameLabel )
				m_pItemCollectionNameLabel->SetFont( m_pFontNameLarge );
			if ( m_pItemCollectionListLabel )
				m_pItemCollectionListLabel->SetFont( m_pFontAttribLarge );
			break;

		case 2:
			m_pItemNameLabel->SetFont( m_pFontNameSmall );
			m_pItemAttribLabel->SetFont( m_pFontAttribSmall );
			if ( m_pItemCollectionNameLabel )
				m_pItemCollectionNameLabel->SetFont( m_pFontNameSmall );
			if ( m_pItemCollectionListLabel )
				m_pItemCollectionListLabel->SetFont( m_pFontAttribSmall );
			break;

		case 3:
			m_pItemNameLabel->SetFont( m_pFontNameSmallest );
			m_pItemAttribLabel->SetFont( m_pFontAttribSmallest );
			if ( m_pItemCollectionNameLabel )
				m_pItemCollectionNameLabel->SetFont( m_pFontNameSmallest );
			if ( m_pItemCollectionListLabel )
				m_pItemCollectionListLabel->SetFont( m_pFontAttribSmallest );
			break;

		case 4:
			m_pItemNameLabel->SetFont( m_pFontNameLarger );
			m_pItemAttribLabel->SetFont( m_pFontAttribLarger );
			if ( m_pItemCollectionNameLabel )
				m_pItemCollectionNameLabel->SetFont( m_pFontNameLarger );
			if ( m_pItemCollectionListLabel )
				m_pItemCollectionListLabel->SetFont( m_pFontAttribLarger );
			break;
		}

		m_pItemNameLabel->SizeToContents();
		m_pItemAttribLabel->SizeToContents();
		if ( m_pItemCollectionNameLabel )
			m_pItemCollectionNameLabel->SizeToContents();
		if ( m_pItemCollectionListLabel )
			m_pItemCollectionListLabel->SizeToContents();
	}
	else
	{
		m_pItemNameLabel->SetFont( m_pFontNameLarge );
		m_pItemNameLabel->SetCenterWrap( false );
		m_pItemNameLabel->SizeToContents();
		m_pItemAttribLabel->SetFont( m_pFontAttribLarge );
		m_pItemAttribLabel->SizeToContents();
		if ( m_pItemCollectionNameLabel )
		{
			m_pItemCollectionNameLabel->SetFont( m_pFontNameLarge );
			m_pItemCollectionNameLabel->SetCenterWrap( false );
			m_pItemCollectionNameLabel->SizeToContents();	
		}
		if ( m_pItemCollectionListLabel )
		{
			m_pItemCollectionListLabel->SetFont( m_pFontAttribLarge );
			m_pItemCollectionListLabel->SizeToContents();
		}

		if ( !m_bResizeToText )
		{
			int iAttribTall = m_pItemAttribLabel->GetWide() ? m_pItemAttribLabel->GetTall() : 0;
			int iNameTall = m_bAttribOnly ? 0 : m_pItemNameLabel->GetTall();
			int iTotalH = iAttribTall + iNameTall;

			// If these fonts won't fit, use the smaller ones
			if ( m_pItemNameLabel->GetWide() > iTextW || (!m_bNameOnly && m_pItemAttribLabel->GetWide() > iTextW) || (iTotalH > h) )
			{
				m_pItemNameLabel->SetFont( m_pFontNameSmall );
				m_pItemAttribLabel->SetFont( m_pFontAttribSmall );

				m_pItemNameLabel->InvalidateLayout( true );
				m_pItemNameLabel->SizeToContents();

				iAttribTall = m_pItemAttribLabel->GetWide() ? m_pItemAttribLabel->GetTall() : 0;
				iNameTall = m_pItemNameLabel->GetTall();
				iTotalH = iAttribTall + iNameTall;

				// If they don't fit, go to the smallest
				if ( m_pItemNameLabel->GetWide() > iTextW || (!m_bNameOnly && m_pItemAttribLabel->GetWide() > iTextW) || (iTotalH > h) )
				{
					m_pItemNameLabel->SetFont( m_pFontNameSmallest );
					m_pItemAttribLabel->SetFont( m_pFontAttribSmallest );

					m_pItemNameLabel->InvalidateLayout( true );
					m_pItemNameLabel->SizeToContents();
				}
			}
		}
	}

	// If it still doesn't fit, turn on wrap and pray
	if ( m_pItemNameLabel->GetWide() > iTextW )
	{
		m_pItemNameLabel->SetCenterWrap( true );
	}

	if ( m_pItemAttribLabel->GetWide() > iTextW )
	{
		m_pItemAttribLabel->SetWrap( true );
	}

	// Now restore the sizes
	m_pItemNameLabel->SetSize( iTextW, m_pItemNameLabel->GetTall() );
	m_pItemAttribLabel->SetSize( iTextW, m_pItemAttribLabel->GetTall() );

	if ( m_pItemEquippedLabel )
	{
		m_pItemEquippedLabel->SetPos( GetWide() - m_pItemEquippedLabel->GetWide() - m_iEquippedInsetX, GetTall() - m_pItemEquippedLabel->GetTall() - m_iEquippedInsetY );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::SetItem( const CEconItemView *pItem )
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );

	HideContainedItemPanel();

	bool bMatch = false;

	if ( pItem && pItem->IsValid() )
	{
		if ( m_ItemData.IsValid() )
		{
			if ( m_ItemData.GetItemID() != INVALID_ITEM_ID )
			{
				bool bUseIndexCompare = false;
					
#ifdef TF_CLIENT_DLL
				if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
				{
					if ( ( m_ItemData.GetItemID() == 1 ) && ( m_ItemData.GetItemID() == pItem->GetItemID() ) )
					{
						// Items the bots carry in MvM all have itemID of 1, so we need to compare the item index
						bUseIndexCompare = true;
					}
				}
#endif
				 
				if ( bUseIndexCompare )
				{
					bMatch = m_ItemData.GetItemDefIndex() == pItem->GetItemDefIndex();
				}
				else
				{
					// Our current item is non-base. We need to match global indices.
					bMatch = ( m_ItemData.GetItemID() == pItem->GetItemID() );
				}
			}
			else if ( pItem->GetItemID() == INVALID_ITEM_ID )
			{
				static CSchemaFieldHandle<CEconItemAttributeDefinition> pAttrib_ToolTarget( "tool target item" );
				bMatch &= pItem->FindAttribute( pAttrib_ToolTarget );

				// Our current item is a base item. Our new item needs to be base too, and match item indices and quality
				bMatch &= ( m_ItemData.GetItemDefIndex() == pItem->GetItemDefIndex() ) &&
						  ( m_ItemData.GetItemQuality() == pItem->GetItemQuality() ) &&
						  ( m_ItemData.GetSOCData() == pItem->GetSOCData() );
			}
		}

		// if we match item so far, check for strange
		if ( bMatch )
		{
			// Are we tracking alternate stats as well?
			for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
			{
				const CEconItemAttributeDefinition *pKillEaterAltAttrDef = GetKillEaterAttr_Score( i ),
					*pKillEaterAltScoreTypeAttrDef = GetKillEaterAttr_Type( i );
				if ( !pKillEaterAltAttrDef || !pKillEaterAltScoreTypeAttrDef )
					continue;

				uint32 unNewScore = 0;
				uint32 unOldScore = 0;
				bool bNewFoundAttr = pItem->FindAttribute( pKillEaterAltAttrDef, &unNewScore );
				bool bOldFoundAttr = m_ItemData.FindAttribute( pKillEaterAltAttrDef, &unOldScore );
				if ( bNewFoundAttr != bOldFoundAttr || unNewScore != unOldScore )
				{
					// different score
					bMatch = false;
					break;
				}

				float flNewType = 0.f;
				float flOldType = 0.f;
				bNewFoundAttr = FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pKillEaterAltScoreTypeAttrDef, &flNewType );
				bOldFoundAttr = FindAttribute_UnsafeBitwiseCast<attrib_value_t>( &m_ItemData, pKillEaterAltScoreTypeAttrDef, &flOldType );
				if ( bNewFoundAttr != bOldFoundAttr || flNewType != flOldType )
				{
					// different score
					bMatch = false;
					break;
				}
			}
		}

		if ( !bMatch )
		{
			// cancel weapon skin composition for old item
			if ( m_ItemData.IsValid() )
			{
				m_ItemData.CancelWeaponSkinComposite();
			}

			m_ItemData = *pItem;

			if ( m_bIsMouseOverPanel )
			{
				LoadResFileForCurrentItem( false );
			}

			// If the item hasn't built its attribute string, go ahead and do that.
			m_ItemData.SetGrayedOutReason( GetGreyedOutReason() );
		}
		else
		{
			// The rest of the data may match, but we still need the inventory position updates
			m_ItemData.SetInventoryPosition( pItem->GetInventoryPosition() );
		}

		ShowContainedItemPanel( pItem );
	}
	else
	{
		// cancel weapon skin composition for old item
		if ( m_ItemData.IsValid() )
		{
			m_ItemData.CancelWeaponSkinComposite();
		}
		else
		{
			bMatch = true;
		}

		m_ItemData.GetAttributeList()->DestroyAllAttributes();
		m_ItemData.Invalidate();
	}

	// only update panels when item is not matched
	if ( !bMatch )
	{
		UpdatePanels();
	}

	// TODO: Update only description for strange item in the same panel
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::Dragged( bool bDragging )
{
	if ( m_pContainedItemPanel )
	{
		if ( bDragging )
		{
			m_pContainedItemPanel->SetActAsButton( false, false );
			m_pContainedItemPanel->SetVisible( false );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::ShowContainedItemPanel( const CEconItemView *pItem )
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );

	// If this item contains another item, create an interior item model panel.
	if ( pItem->GetSOCData() && pItem->GetSOCData()->GetInteriorItem() && m_pContainedItemPanel )
	{
		if ( !m_pContainedItemPanel->IsContainedItem() )
		{
			m_pContainedItemPanel->SetContainedItem( true );
			m_pContainedItemPanel->InvalidateLayout( false, true );
		}

		CEconItem *pInteriorItem = pItem->GetSOCData()->GetInteriorItem();
		if ( !pInteriorItem )
			return;

		const IEconTool *pEconTool = pItem->GetItemDefinition()
								   ? pItem->GetItemDefinition()->GetEconTool()
								   : NULL;
		if ( !pEconTool )
			return;

		if ( !pEconTool->ShouldShowContainedItemPanel( pItem ) )
		{
			// Only show this to non-local, non-wrapping players if we've been told to (usually in trading panel)
			if ( !m_bShowOthersGiftWrappedItems )
				return;
		}

		SetNeedsToLoad();

		m_pContainedItemPanel->SetEconItem( pInteriorItem );
		m_pContainedItemPanel->SetVisible( true );
		m_pContainedItemPanel->SetActAsButton( false, true );
		m_pContainedItemPanel->SetTooltip( GetTooltip(), "" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::HideContainedItemPanel()
{
	if ( m_pContainedItemPanel && m_pContainedItemPanel->IsVisible() )
	{
		m_pContainedItemPanel->SetActAsButton( false, false );
		m_pContainedItemPanel->SetVisible( false );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::SetEconItem( CEconItem* pItem )
{
	m_ItemData.SetItemDefIndex( pItem->GetDefinitionIndex() );
	m_ItemData.SetItemQuality( pItem->GetQuality() );
	m_ItemData.SetItemLevel( pItem->GetItemLevel() );
	m_ItemData.SetItemID( pItem->GetItemID() );
	m_ItemData.SetNonSOEconItem( pItem );
	m_ItemData.SetInitialized( true );

#ifdef CLIENT_DLL
	m_ItemData.SetIsTradeItem( false );
	m_ItemData.SetItemQuantity( pItem->GetQuantity() );
#endif

	m_ItemData.GetAttributeList()->DestroyAllAttributes();

	if ( m_pModelPanel )
	{
		m_pModelPanel->SetItem( &m_ItemData );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::SetNoItemText( const char *pszText ) 
{
	m_pszNoItemText = pszText;
	CleanupNoItemWChars();

	if ( !HasItem() ) 
	{
		UpdatePanels(); 
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::CleanupNoItemWChars( void )
{
	if ( m_pwcNoItemText )
	{
		delete m_pwcNoItemText;
		m_pwcNoItemText = NULL;
	}
	if ( m_pwcNoItemAttrib )
	{
		delete m_pwcNoItemAttrib;
		m_pwcNoItemAttrib = NULL;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CItemModelPanel::UpdateSeriesLabel()
{
	// hijacking m_bShowQuantity here to indicate "show things where the quantity counter goes", in this case meaning "show crate series indicator"
	if ( m_pSeriesLabel && m_bShowQuantity )
	{
		static CSchemaAttributeDefHandle pAttrDef_CrateSeries( "set supply crate series" );
		static CSchemaAttributeDefHandle pAttrDef_HideSeries( "hide crate series number" );

		float fCrateSeries;
		if ( pAttrDef_CrateSeries && FindAttribute_UnsafeBitwiseCast<attrib_value_t>( &m_ItemData, pAttrDef_CrateSeries, &fCrateSeries ) && pAttrDef_HideSeries && !m_ItemData.FindAttribute( pAttrDef_HideSeries ) )
		{
			wchar_t wszSeries[16]=L"";
			_snwprintf( wszSeries, ARRAYSIZE( wszSeries ), L"#%i", (int)fCrateSeries );
			m_pSeriesLabel->SetVisible( true );
			m_pSeriesLabel->SetText( wszSeries );
			
			return true;
		}
		else
		{
			m_pSeriesLabel->SetVisible( false );

			return false;
		}
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Read through a few items and see if they match the recipe's criteria
//			Show elipses while still tallying.  Remove our tick once all items
//			are tallied.
//-----------------------------------------------------------------------------
bool CItemModelPanel::CheckRecipeMatches()
{
	// Don't do this if either we or our parent are invisible
	if( !IsVisible() || ( GetParent() && !GetParent()->IsVisible() ) )
		return false;

	const IEconTool* pTool = m_ItemData.GetStaticData()->GetEconTool();

	// If this isnt a dynamic recipe tool, dont show or do any of this
	if( !pTool 
		|| V_stricmp( m_ItemData.GetStaticData()->GetEconTool()->GetTypeName() , "dynamic_recipe")
		|| m_ItemData.GetStaticData()->GetDefaultLoadoutSlot() != INVALID_EQUIPPED_SLOT )
	{
		if( m_pMatchesLabel )
		{
			m_pMatchesLabel->SetVisible( false );
		}

		return false;
	}

	bool bStillWorking = true;
	if( m_pMatchesLabel && m_bShowQuantity )
	{
		CPlayerInventory *pLocalInv = TFInventoryManager()->GetLocalInventory();
		if ( pLocalInv == NULL )
			return false;

		// We still need to match recipe components
		if ( m_nRecipeMatchingIndex < pLocalInv->GetItemCount() )
			sai_NumLoadingRequests[LOADING_RECIPE_MATCHES]++;

		if ( se_CurrentLoadingTask == LOADING_RECIPE_MATCHES )
		{
			// Go through our entire backpack and check for matches, but only go through a few at a time
			while ( m_nRecipeMatchingIndex < pLocalInv->GetItemCount() && sm_flLoadingTimeThisFrame < tf_time_loading_item_panels.GetFloat() )
			{
				// Mark this time
				float flTime = Plat_FloatTime();

				CEconItemView *pItem = pLocalInv->GetItem( m_nRecipeMatchingIndex );
				Assert( pItem );

				// Check each item
				CRecipeComponentMatchingIterator matchingIterator( &m_ItemData, pItem );
				m_ItemData.IterateAttributes( &matchingIterator );
				const CUtlVector< const CEconItemAttributeDefinition* >& matchingAttribs = matchingIterator.GetMatchingComponentInputs();
				Assert( matchingAttribs.Count() <= 1 );
				FOR_EACH_VEC( matchingAttribs, j )
				{
					CAttribute_DynamicRecipeComponent value;
					const CEconItemAttributeDefinition* pAttrib = matchingAttribs[j];
					attrib_definition_index_t nIndex = pAttrib->GetDefinitionIndex();
					m_ItemData.FindAttribute( pAttrib, &value );

					// Add this entry if it doesnt exist in out map yet
					if( m_mapMatchingAttributes.Find( nIndex ) == m_mapMatchingAttributes.InvalidIndex() )
					{
						m_mapMatchingAttributes.Insert( nIndex );
						m_mapMatchingAttributes[ m_mapMatchingAttributes.Find( nIndex ) ] = 0;
					}

					// Increment this value if it's less than the max needed
					int &nCount = m_mapMatchingAttributes[ m_mapMatchingAttributes.Find( nIndex ) ];
					if( (unsigned)nCount < ( value.num_required() - value.num_fulfilled() ) )
					{
						++nCount;
					}
				}

				m_nRecipeMatchingIndex++;
				// Accumulate time
				sm_flLoadingTimeThisFrame += ( Plat_FloatTime() - flTime );
			}
		}

		bStillWorking = m_nRecipeMatchingIndex != pLocalInv->GetItemCount();
		wchar_t wszMatches[16]=L"...";
		
		if( !bStillWorking )
		{
			CRecipeComponentMatchingIterator matchingIterator( &m_ItemData, NULL );
			m_ItemData.IterateAttributes( &matchingIterator );
			int nTotalAttribs = matchingIterator.GetTotalInputs() - matchingIterator.GetInputsFulfilled();
			int nMatchingAttribs = 0;

			unsigned short index = m_mapMatchingAttributes.FirstInorder();
			while( index != m_mapMatchingAttributes.InvalidIndex() )
			{
				nMatchingAttribs += m_mapMatchingAttributes[ index ];
				index = m_mapMatchingAttributes.NextInorder( index );
			}

			// Fill out the actual number of matches
			_snwprintf( wszMatches, ARRAYSIZE( wszMatches ), L"%i/%i", nMatchingAttribs, nTotalAttribs );
		}
	
		m_pMatchesLabel->SetVisible( true );
		m_pMatchesLabel->SetText( wszMatches );
	}

	return bStillWorking;
}

void CItemModelPanel::UpdateDescription()
{
	if ( !m_bDescriptionDirty )
		return;

	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );

	m_bDescriptionDirty = false;
	
	enum { kAttribBufferSize = 4 * 1024 };
	wchar_t wszAttribBuffer[ kAttribBufferSize ] = L"";

	enum { kCollectionBufferSize = 4 * 1024 };
	wchar_t wszCollectionListBuffer[kCollectionBufferSize] = L"";

	wchar_t wszCollectionNameBuffer[512] = L"";

	if ( !m_bNameOnly )
	{
		const CEconItemDescription *pDescription = m_ItemData.GetDescription();
		if ( pDescription )
		{
			unsigned int unWrittenLines = 0;
			unsigned int unWrittenCollectionLines = 0;
			for ( unsigned int i = 0; i < pDescription->GetLineCount(); i++ )
			{
				const econ_item_description_line_t& line = pDescription->GetLine(i);

				// m_bSpecialAttributesOnly, only show purple and orange text, ignore rest
				if ( m_bSpecialAttributesOnly )
				{
					if ( line.eColor == ATTRIB_COL_UNUSUAL || line.eColor == ATTRIB_COL_STRANGE )
					{
						V_wcscat_safe( wszAttribBuffer, unWrittenLines++ == 0 ? L"" : L"\n" );					// add empty lines everywhere except before the first line
						V_wcscat_safe( wszAttribBuffer, line.sText.Get() );
					}	
				}
				else if ( ( line.unMetaType & kDescLineFlag_CollectionName ) != 0 )
				{
					// Ignore name spacers
					if ( !( line.unMetaType & kDescLineFlag_Empty) )
					{
						V_wcscat_safe( wszCollectionNameBuffer, line.sText.Get() );
					}
				}
				else if ( ( line.unMetaType & kDescLineFlag_Collection ) != 0 )
				{		
					V_wcscat_safe( wszCollectionListBuffer, unWrittenCollectionLines++ == 0 ? L"" : L"\n" );					// add empty lines everywhere except before the first line
					V_wcscat_safe( wszCollectionListBuffer, line.sText.Get() );
				}
				else if ( (line.unMetaType & kDescLineFlag_Name ) == 0 )
				{
					V_wcscat_safe( wszAttribBuffer, unWrittenLines++ == 0 ? L"" : L"\n" );					// add empty lines everywhere except before the first line
					V_wcscat_safe( wszAttribBuffer, line.sText.Get() );
				}
			}

			// If we have an unknown name, we should try to rebuild for "awhile"
			m_bDescriptionDirty |= pDescription->HasUnknownPlayer();
		}
	}
		
	if( m_pMainContentContainer )
	{
		m_pMainContentContainer->SetDialogVariable( "attriblist", wszAttribBuffer );
		m_pMainContentContainer->SetDialogVariable( "collectionname", wszCollectionNameBuffer );
		m_pMainContentContainer->SetDialogVariable( "collectionlist", wszCollectionListBuffer );
		m_pMainContentContainer->SetDialogVariable( "itemname", m_ItemData.GetItemName() );
	}

	if ( m_pItemNameLabel )
	{
		// Set the name to the quality color
		// Rarity Econ Colorization
		EEconItemQuality eQuality = (EEconItemQuality)m_ItemData.GetItemQuality();
		if ( GetItemSchema()->GetRarityColor( m_ItemData.GetItemDefinition()->GetRarity() ) && eQuality != AE_SELFMADE )
		{
			m_pItemNameLabel->SetColorStr( GetItemSchema()->GetRarityColor( m_ItemData.GetItemDefinition()->GetRarity() ) );
		}
		else 
		{
			const char *pszQualityColorString = EconQuality_GetColorString( eQuality );
			if ( m_ItemData.IsValid() && !m_bStandardTextColor && pszQualityColorString )
			{
				m_pItemNameLabel->SetColorStr( pszQualityColorString );
			}
			else
			{
				m_pItemNameLabel->SetColorStr( m_OrgItemTextColor );
			}
		}
		m_pItemNameLabel->SetVisible( !m_bAttribOnly );
	}

	if ( m_pItemAttribLabel )
	{
		m_pItemAttribLabel->SetVisible( !m_bNameOnly );
	}

	bool bCollectionVisible = m_bHideCollectionPanel ? false : !m_bNameOnly;

	if ( m_pItemCollectionNameLabel )
	{
		m_pItemCollectionNameLabel->SetVisible( bCollectionVisible );
	}
	if ( m_pItemCollectionListLabel )
	{
		m_pItemCollectionListLabel->SetVisible( bCollectionVisible );
	}
	if ( m_pItemCollectionHighlight )
	{
		m_pItemCollectionHighlight->SetVisible( bCollectionVisible );
	}

	InvalidateLayout( true );

	// Now that we've built the attribute description, give the attribute colors to our label
	if ( m_pItemAttribLabel && !m_bNameOnly && m_pItemAttribLabel->GetTextImage() && m_ItemData.GetDescription() )
	{
		const CEconItemDescription *pDescription = m_ItemData.GetDescription();
		vgui::TextImage *pAttrTextImage = m_pItemAttribLabel->GetTextImage();
		pAttrTextImage->ClearColorChangeStream();

		vgui::TextImage *pCollectionNameTextImage = m_pItemCollectionNameLabel ? m_pItemCollectionNameLabel->GetTextImage() : NULL;
		if ( pCollectionNameTextImage )
			pCollectionNameTextImage->ClearColorChangeStream();

		vgui::TextImage *pCollectionListTextImage = m_pItemCollectionListLabel ? m_pItemCollectionListLabel->GetTextImage() : NULL;
		if ( pCollectionListTextImage )
			pCollectionListTextImage->ClearColorChangeStream();

		vgui::IScheme *pScheme = scheme()->GetIScheme( GetScheme() );

		Color prevAttrColor(0,0,0);
		Color prevCollectionColor(0,0,0);
		unsigned int unCurrentAttrTextStreamIndex = 0;
		unsigned int unCurrentCollectionNameTextStreamIndex = 0;
		unsigned int unCurrentCollectionListTextStreamIndex = 0;
		int iCollectionLineCount = 0;

		if ( m_pItemCollectionHighlight )
		{
			m_pItemCollectionHighlight->SetVisible( false );
		}

		for ( unsigned int i = 0; i < pDescription->GetLineCount(); i++ )
		{
			const econ_item_description_line_t& line = pDescription->GetLine(i);

			// Ignore the name line, it was added above
			if ( ( line.unMetaType & kDescLineFlag_Name ) != 0 )
			{
				continue;
			}

			// collection
			int fontHeight = surface()->GetFontTall( m_pFontAttribSmall );
			if ( ( line.unMetaType & (kDescLineFlag_Collection | kDescLineFlag_CollectionName | kDescLineFlag_CollectionCurrentItem ) ) != 0 && pCollectionNameTextImage && pCollectionListTextImage )
			{
				bool bIsCollectionName = ( line.unMetaType & kDescLineFlag_CollectionName ) != 0;
				vgui::TextImage *pTextImage = bIsCollectionName ? pCollectionNameTextImage : pCollectionListTextImage;
				unsigned int &unCurrentCollectionTextStreamIndex = bIsCollectionName ? unCurrentCollectionNameTextStreamIndex : unCurrentCollectionListTextStreamIndex;

				bool bIsCurrentItem = ( line.unMetaType & kDescLineFlag_CollectionCurrentItem ) != 0;
				// use bg color as text color for current item for a better highlight
				Color col = bIsCurrentItem ? Color( 0, 0, 0, 255 ) : pScheme->GetColor( GetColorNameForAttribColor( line.eColor ), Color( 255, 255, 255, 255 ) );
				// Output a color change if necessary.
				if ( i == 0 || prevCollectionColor != col )
				{
					pTextImage->AddColorChange( col, unCurrentCollectionTextStreamIndex );
					prevCollectionColor = col;
				}

				unCurrentCollectionTextStreamIndex += StringFuncs<locchar_t>::Length( line.sText.Get() ) + 1;	// add one character to deal with newlines

				if ( bIsCollectionName )
				{
					continue;
				}

				// Current line highlight
				if ( bIsCurrentItem && m_pItemCollectionHighlight )
				{
					// use text color as bg color for the current item for a better highlight
					Color bgColor = pScheme->GetColor( GetColorNameForAttribColor( line.eColor ), Color( 255, 255, 255, 255 ) );

					// Get the current ypos
					int x, y;
					m_pItemCollectionListLabel->GetPos( x, y );
					m_pItemCollectionHighlight->SetPos( x, y + iCollectionLineCount * fontHeight );
					m_pItemCollectionHighlight->SetBgColor( bgColor );
					m_pItemCollectionHighlight->SetVisible( bCollectionVisible );
				}
				iCollectionLineCount++;
			}
			else 
			{
				Color col = pScheme->GetColor( GetColorNameForAttribColor( line.eColor ), Color( 255, 255, 255, 255 ) );

				// m_bSpecialAttributesOnly, only show purple and orange text, ignore rest
				if ( m_bSpecialAttributesOnly )
				{
					if ( ( line.eColor != ATTRIB_COL_UNUSUAL && line.eColor != ATTRIB_COL_STRANGE ) )
					{
						continue;
					}
				}

				// Output a color change if necessary.
				if ( i == 0 || prevAttrColor != col )
				{
					pAttrTextImage->AddColorChange( col, unCurrentAttrTextStreamIndex );
					prevAttrColor = col;
				}
				unCurrentAttrTextStreamIndex += StringFuncs<locchar_t>::Length( line.sText.Get() ) + 1;	// add one character to deal with newlines
			}
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::DirtyDescription()
{
	m_bDescriptionDirty = true;

	if ( HasItem() )
		GetItem()->OnAttributeValuesChanged();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CItemModelPanel::UpdateMatchesLabel()
{
	const IEconTool* pTool = m_ItemData.GetStaticData()->GetEconTool();

	if( !pTool || Q_stricmp( m_ItemData.GetStaticData()->GetEconTool()->GetTypeName() , "dynamic_recipe") )
	{
		return false;
	}

	m_nRecipeMatchingIndex = 0;
	m_mapMatchingAttributes.Purge();
	SetNeedsToLoad();
	
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CItemModelPanel::UpdateQuantityLabel()
{
	if ( m_pItemQuantityLabel )
	{
		bool bVisible = m_bShowQuantity && m_ItemData.GetStaticData() != NULL;
		if ( bVisible )
		{
			const IEconTool *pEconTool = m_ItemData.GetStaticData()->GetEconTool();
			if ( pEconTool && pEconTool->ShouldDisplayQuantity( &m_ItemData ) )
			{
				wchar_t wszQuantity[16]=L"";
				_snwprintf( wszQuantity, ARRAYSIZE( wszQuantity ), L"%i", m_ItemData.GetQuantity() );
				m_pItemQuantityLabel->SetVisible( true );
				m_pItemQuantityLabel->SetText( wszQuantity );
			}
			else
			{
				bVisible = false;
			}
		}
		m_pItemQuantityLabel->SetVisible( bVisible );

		return true;
	}

	return false;
}

//--------------------------------------------------------------------------------------------------------
/**
 * Simple utility function to allocate memory and duplicate a wide string
 */
inline wchar_t *CloneWString( const wchar_t *str )
{
	const int nLen = V_wcslen(str)+1;
	wchar_t *cloneStr = new wchar_t [ nLen ];
	const int nSize = nLen * sizeof( wchar_t );
	V_wcsncpy( cloneStr, str, nSize );
	return cloneStr;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::SetNoItemText( const wchar_t *pwszTitleOverride, const wchar_t *pwszAttribs, int iNegAttribsBegin )
{ 
	static CSchemaColorDefHandle pColorDef_DescAttribPositive( "desc_attrib_positive" );
	static CSchemaColorDefHandle pColorDef_DescAttribNegative( "ItemAttribNegative" );

	CleanupNoItemWChars();

	m_pwcNoItemText = CloneWString( pwszTitleOverride );
	m_pszNoItemText = NULL;

	if ( pwszAttribs )
	{
		m_pwcNoItemAttrib = CloneWString( pwszAttribs ); 

		if ( m_pItemAttribLabel && m_pItemAttribLabel->GetTextImage() )
		{
			m_pItemAttribLabel->GetTextImage()->ClearColorChangeStream();

			if ( iNegAttribsBegin )
			{
				vgui::IScheme *pScheme = scheme()->GetIScheme( GetScheme() );

				if ( pColorDef_DescAttribPositive )
				{
					Color col = pScheme->GetColor( pColorDef_DescAttribPositive->GetColorName(), Color(255,255,255,255) );
					m_pItemAttribLabel->GetTextImage()->AddColorChange( col, 0 );
				}

				if ( pColorDef_DescAttribNegative )
				{
					Color col = pScheme->GetColor( pColorDef_DescAttribNegative->GetColorName(), Color(255,255,255,255) );
					m_pItemAttribLabel->GetTextImage()->AddColorChange( col, iNegAttribsBegin );
				}
			}
		}
	}

	if ( !HasItem() ) 
	{
		UpdatePanels(); 
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::HideAllModifierIcons()
{
	if ( m_pPaintIcon )
	{
		m_pPaintIcon->SetVisible( false );
	}
	if ( m_pTF2Icon )
	{
		m_pTF2Icon->SetVisible( false );
	}
	if ( m_pItemEquippedLabel )
	{
		m_pItemEquippedLabel->SetVisible( false );
	}
	if ( m_pItemQuantityLabel )
	{
		m_pItemQuantityLabel->SetVisible( false );
	}
	if ( m_pVisionRestrictionImage )
	{
		m_pVisionRestrictionImage->SetVisible( false );
	}
	if ( m_pIsStrangeImage )
	{
		m_pIsStrangeImage->SetVisible( false );
	}
	if ( m_pIsUnusualImage )
	{
		m_pIsUnusualImage->SetVisible( false );
	}
	if ( m_pIsLoanerImage )
	{
		m_pIsLoanerImage->SetVisible( false );
	}
	if ( m_pSeriesLabel )
	{
		m_pSeriesLabel->SetVisible( false );
	}
	if ( m_pMatchesLabel )
	{
		m_pMatchesLabel->SetVisible( false );
	}
	if ( m_pItemEquippedLabel && m_bForceShowEquipped )
	{
		m_pItemEquippedLabel->SetVisible( m_bForceShowEquipped );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::UpdatePanels( void )
{
	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );

	if ( !m_pModelPanel )
		return;

	m_pModelPanel->SetModelHidden( m_bHideModel );

	// By default we dont need a tick.
	vgui::ivgui()->RemoveTickSignal( GetVPanel() );

	// Default to loading icons
	se_CurrentLoadingTask = LOADING_ICONS;

	m_pModelPanel->SetItem( &m_ItemData );
	// We need to load if our image isn't in memory already.
	if ( !m_bHideModel && ( m_pModelPanel->IsImageNotLoaded() || m_pModelPanel->IsLoadingWeaponSkin() ) )
	{
		if ( m_pMainContentContainer )
		{
			m_pMainContentContainer->SetVisible( false );
		}

		// Show the spinner
		if ( m_pLoadingSpinner )
		{
			m_pLoadingSpinner->SetVisible( true );
		}

		SetNeedsToLoad();
	}
	else
	{
		// hide the spinner
		if ( m_pLoadingSpinner )
		{
			m_pLoadingSpinner->SetVisible( false );
		}
	}

	if ( !HasItem() )
	{
		if ( m_bModelOnly )
		{
			if ( m_pItemNameLabel )
			{
				m_pItemNameLabel->SetVisible( false );
			}
			if ( m_pItemAttribLabel )
			{
				m_pItemAttribLabel->SetVisible( false );
			}
		}
		else
		{
			if ( m_pItemNameLabel )
			{
				const wchar_t *wcNOText = NULL;
				if ( m_pszNoItemText && m_pszNoItemText[0] )
				{
					wcNOText = g_pVGuiLocalize->Find( m_pszNoItemText ); 
				}
				else if ( m_pwcNoItemText )
				{
					wcNOText = m_pwcNoItemText;
				}

				if ( wcNOText && wcNOText[0] )
				{
					if ( m_pMainContentContainer )
						m_pMainContentContainer->SetDialogVariable( "itemname", wcNOText );
					m_pItemNameLabel->SetVisible( true );
					m_pItemNameLabel->SetColorStr( m_NoItemTextColor );

					m_pItemNameLabel->InvalidateLayout(true,true);
					if ( m_iForceTextSize && m_iForceTextSize <= 3 )
					{
						// Leave center wrap on if the noitem text is getting to use the whole panel
						if ( !m_bNoItemFullPanel )
						{
							m_pItemNameLabel->SetCenterWrap( false );
						}

						switch ( m_iForceTextSize )
						{
						case 1:
							m_pItemNameLabel->SetFont( m_pFontNameLarge );
							break;

						case 2:
							m_pItemNameLabel->SetFont( m_pFontNameSmall );
							break;

						case 3:
							m_pItemNameLabel->SetFont( m_pFontNameSmallest );
							break;
						}
					}
				}
				else
				{
					m_pItemNameLabel->SetVisible( false );
				}
			}
			
			if ( !m_bNameOnly && m_pwcNoItemAttrib )
			{
				if ( m_pMainContentContainer )
					m_pMainContentContainer->SetDialogVariable( "attriblist", m_pwcNoItemAttrib );
				if ( m_pItemAttribLabel && !m_pItemAttribLabel->IsVisible() )
				{
					m_pItemAttribLabel->SetVisible( true );
				}
			}
			else
			{
				if ( m_pItemAttribLabel && m_pItemAttribLabel->IsVisible() )
				{
					m_pItemAttribLabel->SetVisible( false );
				}
			}
		}

		HideAllModifierIcons();
		return;
	}

	if ( m_bHideModifierIcons )
	{
		HideAllModifierIcons();
		return;
	}

	if ( m_pPaintIcon )
	{
		m_pPaintIcon->SetVisible( false );
		if ( !m_bHideModel && !m_bHidePaintIcon )
		{
			// Empty out our list of paint colors. We may or may not put things back in -- an empty
			// list at the end means "don't draw the paint icon".
			m_pPaintIcon->m_colPaintColors.RemoveAll();

			// Fetch custom texture, if any
			m_pPaintIcon->m_hUGCId = m_ItemData.GetCustomUserTextureID();
			if ( m_pPaintIcon->m_hUGCId != 0 )
				m_pPaintIcon->SetVisible( true );

			// Don't show paint icons on any tools, their icon contains the color
			const bool bIsEconTool = m_ItemData.GetItemDefinition()->IsTool();

			// Has the item been painted?
			int iRGB0 = m_ItemData.GetModifiedRGBValue( false ),
				iRGB1 = m_ItemData.GetModifiedRGBValue( true );

			if ( !bIsEconTool && (iRGB0 != 0 || iRGB1 != 0))
			{
				m_pPaintIcon->SetVisible( true );
				m_pPaintIcon->m_colPaintColors.AddToTail( Color( clamp( (iRGB0 & 0xFF0000) >> 16, 0, 255 ), clamp( (iRGB0 & 0xFF00) >> 8, 0, 255 ), clamp( (iRGB0 & 0xFF), 0, 255 ), 255 ) );
				if ( iRGB0 != iRGB1 )
				{
					m_pPaintIcon->m_colPaintColors.AddToTail( Color( clamp( (iRGB1 & 0xFF0000) >> 16, 0, 255 ), clamp( (iRGB1 & 0xFF00) >> 8, 0, 255 ), clamp( (iRGB1 & 0xFF), 0, 255 ), 255 ) );
				}
			}
		}
	}

	if ( m_pTF2Icon )
	{
		if ( m_bHideModel || m_bHidePaintIcon )
		{
			m_pTF2Icon->SetVisible( false );
		}
		else
		{
			m_pTF2Icon->SetVisible( m_ItemData.GetSOCData() && m_ItemData.GetSOCData()->IsForeign() );
		}
	}

	if ( m_bNoItemFullPanel )
	{
		// If we're a noitem-fullpanel mode, we don't show strings when we have an item.
		m_pItemNameLabel->SetVisible( false );
		m_pItemAttribLabel->SetVisible( false );
	}
	else if ( m_bModelOnly )
	{
		if ( m_pItemNameLabel )
		{
			m_pItemNameLabel->SetVisible( false );
		}
		if ( m_pItemAttribLabel )
		{
			m_pItemAttribLabel->SetVisible( false );
		}
	}
	else
	{
		// deferred description loading
		m_bDescriptionDirty = true;
		SetNeedsToLoad();
		if ( m_pMainContentContainer )
			m_pMainContentContainer->SetDialogVariable( "itemname", "" );
	}

	if ( m_pItemEquippedLabel )
	{
		m_pItemEquippedLabel->SetVisible( m_bForceShowEquipped || (m_bShowEquipped && IsEquipped()) );
	}

	// Hide all of these labels
	if( m_pMatchesLabel )
	{
		m_pMatchesLabel->SetVisible( false );
	}

	if( m_pSeriesLabel )
	{
		m_pSeriesLabel->SetVisible( false );
	}

	if( m_pItemQuantityLabel )
	{
		m_pItemQuantityLabel->SetVisible( false );
	}


	// Update that number in the top right
	if ( !UpdateMatchesLabel() )
	{
		if ( !UpdateSeriesLabel() )
		{
			UpdateQuantityLabel();
		}
	}

	if ( m_pVisionRestrictionImage )
	{
		int nVisionFilterFlags = 0;
		const CEconItemDefinition *pData = m_ItemData.GetItemDefinition();
		if ( !m_bModelOnly && pData )
		{
			nVisionFilterFlags = pData->GetVisionFilterFlags();

			// Add support for all the holidays and "vision" mode restrictions
			if ( pData->GetHolidayRestriction() )
			{
				int iHolidayRestriction = UTIL_GetHolidayForString( pData->GetHolidayRestriction() );
				switch ( iHolidayRestriction )
				{
				default:
				case kHoliday_None:
				case kHoliday_TFBirthday:
				case kHoliday_Christmas:
				case kHoliday_Valentines:
				case kHoliday_MeetThePyro:
				case kHoliday_AprilFools:
				case kHoliday_EOTL:
				case kHoliday_CommunityUpdate:
					break;

				case kHoliday_Halloween:
				case kHoliday_FullMoon:
				case kHoliday_HalloweenOrFullMoon:
				case kHoliday_HalloweenOrFullMoonOrValentines:
					#ifdef TF_CLIENT_DLL
						nVisionFilterFlags |= TF_VISION_FILTER_HALLOWEEN;
					#endif
					break;
				}
			}
		}

		switch ( nVisionFilterFlags )
		{
			default:
				AssertMsg1( false, "Unexpected vision restriction flags %d", nVisionFilterFlags );
			case 0:
				m_pVisionRestrictionImage->SetVisible( false );
				break;
#ifdef TF_CLIENT_DLL
			case 1:
				m_pVisionRestrictionImage->SetImage( "viewmode_pyrovision" );
				m_pVisionRestrictionImage->SetVisible( true );
				break;
			case 2:
				// Check if most players who have not specifically opted in will see the item.
				if ( TFGameRules() ? TFGameRules()->IsHolidayActive( kHoliday_HalloweenOrFullMoon ) : TF_IsHolidayActive( kHoliday_HalloweenOrFullMoon ) )
				{
					m_pVisionRestrictionImage->SetImage( "viewmode_spooky" );
				}
				else
				{
					m_pVisionRestrictionImage->SetImage( "viewmode_spooky_off" );
				}
				m_pVisionRestrictionImage->SetVisible( true );
				break;
			case 4:
				m_pVisionRestrictionImage->SetVisible( false );
				break;
#endif
		}
	}

	// Strange Icon
	static CSchemaAttributeDefHandle pAttrDef_StatTrakModule( "weapon_uses_stattrak_module" );
	if ( m_pIsStrangeImage )
	{
		m_pIsStrangeImage->SetVisible( false );

		if ( !m_bIsMouseOverPanel )
		{
			// Allow for already strange items
			bool bIsStrange = false;
			if ( m_ItemData.GetQuality() == AE_STRANGE )
			{
				bIsStrange = true;
			}

			if ( !bIsStrange )
			{
				// Go over the attributes of the item, if it has any strange attributes the item is strange and don't apply
				for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
				{
					if ( m_ItemData.FindAttribute( GetKillEaterAttr_Score( i ) ) )
					{
						bIsStrange = true;
						break;
					}
				}
			}
			if ( bIsStrange )
			{
				if ( pAttrDef_StatTrakModule && m_ItemData.FindAttribute( pAttrDef_StatTrakModule ) )
				{
					m_pIsStrangeImage->SetImage( "viewmode_statclock" );
				}
				else
				{
					m_pIsStrangeImage->SetImage( "viewmode_strange" );
				
				}
				m_pIsStrangeImage->SetVisible( true );
			}
		}
	}
	
	// Unusual Icon
	if ( m_pIsUnusualImage )
	{
		m_pIsUnusualImage->SetVisible( false );
	
		static CSchemaAttributeDefHandle pAttrDef_ParticleEffect( "attach particle effect" );
		static CSchemaAttributeDefHandle pAttrDef_TauntParticle( "on taunt attach particle index" );
		if ( pAttrDef_ParticleEffect && pAttrDef_TauntParticle && !m_bIsMouseOverPanel )
		{
			// Cant use quality cause of old legacy items.  Quality is just a quick test
			if ( m_ItemData.FindAttribute( pAttrDef_ParticleEffect ) || m_ItemData.FindAttribute( pAttrDef_TauntParticle ) )
			{
				m_pIsUnusualImage->SetImage( "viewmode_unusual" );
				m_pIsUnusualImage->SetVisible( true );
			}
		}
	}

	if ( m_pIsLoanerImage )
	{
		m_pIsLoanerImage->SetVisible( false );
		if ( !m_bIsMouseOverPanel && GetAssociatedQuestItemID( &m_ItemData ) != INVALID_ITEM_ID )
		{
			m_pIsLoanerImage->SetImage( "viewmode_loaner" );
			m_pIsLoanerImage->SetVisible( true );
		}
	}

	InvalidateLayout();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CItemModelPanel::IsEquipped( void )
{
	if ( !HasItem() )
		return false;

	return m_ItemData.IsEquipped();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::SetGreyedOut( const char *pszGreyedOutReason ) 
{ 
	m_pszGreyedOutReason = pszGreyedOutReason;
	if ( m_pModelPanel )
	{
		m_pModelPanel->SetGreyedOut( m_pszGreyedOutReason != NULL );
	}
	UpdateEquippedLabel(); 
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CItemModelPanel::HasItem( void )
{
	return m_ItemData.IsValid();
}

void CItemModelPanel::SetModelIsHidden( bool bHideModel )
{ 
	m_bHideModel = bHideModel;
	if ( m_pModelPanel )
	{
		m_pModelPanel->SetModelHidden( bHideModel );
	}
}

void CItemModelPanel::OnTick()
{
	bool bStillWorking = LoadData();
	if ( m_pContainedItemPanel )
	{
		bStillWorking |= m_pContainedItemPanel->LoadData();
	}

	// If we're done working, we dont need to tick anymore
	if ( !bStillWorking )
	{
		LoadDataCompleted();
	}

	BaseClass::OnTick();
}

void CItemModelPanel::SetNeedsToLoad()
{
	vgui::ivgui()->AddTickSignalToHead( GetVPanel() );
}

bool CItemModelPanel::LoadData()
{
	// Different frame?
	if ( sm_nCurrentDecriptionUpdateFrame != gpGlobals->framecount )
	{
		// Reset
		sm_nCurrentDecriptionUpdateFrame = gpGlobals->framecount;
		sm_flLoadingTimeThisFrame = 0.f;

		// Figure out which loading we're going to do.  We want to load
		// certain things sooner (visual things, ie icons) than we start
		// figuring out recipe matches.
		eLoadingType_t type = NUM_LOADING_TYPES;
		for( int i=0; i < NUM_LOADING_TYPES; ++i )
		{
			if ( sai_NumLoadingRequests[i] > 0 && eLoadingType_t(i) < type )
			{
				type = eLoadingType_t(i);
			}
			sai_NumLoadingRequests[i] = 0;
		}

		se_CurrentLoadingTask = type;
	}

	bool bStillWorking = CheckRecipeMatches();

	if ( !m_bHideModel && m_pModelPanel )
	{
		bool bImageLoaded = true;
		bool bLoadingWeaponSkin = m_pModelPanel->IsLoadingWeaponSkin();
		bool bLoadingBackpackIcon = m_pModelPanel->IsImageNotLoaded();

		if ( bLoadingWeaponSkin || bLoadingBackpackIcon )
		{
			// We still need to load icons
			sai_NumLoadingRequests[LOADING_ICONS]++;
			if ( sm_flLoadingTimeThisFrame < tf_time_loading_item_panels.GetFloat() && se_CurrentLoadingTask == LOADING_ICONS )
			{
				float flTime = Plat_FloatTime();

				// no need to load texture if we're doing composite weapon skin
				if ( bLoadingWeaponSkin )
				{
					g_pMatSystemSurface->BeginSkinCompositionPainting();
					m_pModelPanel->Paint();
					g_pMatSystemSurface->EndSkinCompositionPainting();
				}
			
				if ( bLoadingBackpackIcon )
				{
					m_pModelPanel->LoadInventoryImage();
				}

				// Accumulate time
				sm_flLoadingTimeThisFrame += ( Plat_FloatTime() - flTime );
			}

			bStillWorking = m_pModelPanel->IsLoadingWeaponSkin() || m_pModelPanel->IsImageNotLoaded();
			bImageLoaded = !bStillWorking;
		}

		// Hide the spinner and show the main container
		if ( bImageLoaded )
		{
			if ( m_pMainContentContainer && !m_pMainContentContainer->IsVisible() )
			{
				m_pMainContentContainer->SetVisible( true );
			}

			if ( m_pLoadingSpinner && m_pLoadingSpinner->IsVisible() )
			{
				m_pLoadingSpinner->SetVisible( false );
			}
		}
	}

	if ( m_bDescriptionDirty && !IsContainedItem() )
	{
		// We still need to load our description
		sai_NumLoadingRequests[LOADING_DESCRIPTIONS]++;
		// Check if we're clear to update.  We only want to eat up a little slice of time.
		if ( sm_flLoadingTimeThisFrame < tf_time_loading_item_panels.GetFloat() && se_CurrentLoadingTask == LOADING_DESCRIPTIONS )
		{
			float flTime = Plat_FloatTime();
			// Update!
			UpdateDescription();

			// Accumulate time
			sm_flLoadingTimeThisFrame += ( Plat_FloatTime() - flTime );
		}

		bStillWorking |= m_bDescriptionDirty;
	}

	return bStillWorking;
}

void CItemModelPanel::LoadDataCompleted()
{
	vgui::ivgui()->RemoveTickSignal( GetVPanel() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::SetActAsButton( bool bClickable, bool bMouseOver ) 
{ 
	m_bClickable = bClickable; 
	m_bMouseOver = bMouseOver; 

	SetMouseInputEnabled( m_bClickable || m_bMouseOver );
}

void CItemModelPanel::NavigateTo()
{
	BaseClass::NavigateTo();

	if ( IsPC() )
	{
		RequestFocus( 0 );
	}
}

void CItemModelPanel::NavigateFrom()
{
	BaseClass::NavigateFrom();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::OnCursorEntered( void )
{
	if ( !m_bMouseOver )
		return;

	if ( m_bShouldSendPanelEnterExits )
	{
		PostActionSignal( new KeyValues("ItemPanelEntered") );
	}

	if ( IsEnabled() && !IsSelected() )
	{
		NavigateTo();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::OnCursorExited( void )
{
	if ( !m_bMouseOver )
		return;

	if ( m_bShouldSendPanelEnterExits )
	{
		PostActionSignal( new KeyValues("ItemPanelExited") );
	}

	if ( IsSelected() )
	{
		NavigateFrom();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
extern ISoundEmitterSystemBase *soundemitterbase;
void CItemModelPanel::OnMousePressed(vgui::MouseCode code)
{
	if ( code == MOUSE_RIGHT )
	{
		PostActionSignal( new KeyValues("ItemPanelMouseRightRelease") );
	}

	if ( !m_bClickable || code != MOUSE_LEFT )
		return;

	PostActionSignal( new KeyValues("ItemPanelMousePressed") );

	// audible feedback
	const char *soundFilename = "ui/buttonclick.wav";

	if ( m_bUseItemSounds )
	{
		CEconItemView *item = GetItem();
		if ( item )
		{
			soundFilename = item->GetDefinitionString( "mouse_pressed_sound", "ui/item_default_pickup.wav" );
		}
	}

	const char *pszSound = UTIL_GetRandomSoundFromEntry( soundFilename );
	if ( pszSound && pszSound[0] )
	{
		vgui::surface()->PlaySound( pszSound );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::OnMouseReleased(vgui::MouseCode code)
{
	if ( !m_bClickable || code != MOUSE_LEFT )
		return;

	PostActionSignal( new KeyValues("ItemPanelMouseReleased") );

	// audible feedback
	// we're not using item sounds here because they are better handled by the drag/drop code elsewhere
	if ( !m_bUseItemSounds )
	{
		vgui::surface()->PlaySound( "ui/buttonclickrelease.wav" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CItemModelPanel::OnMouseDoublePressed(vgui::MouseCode code)
{
	if ( !m_bClickable || code != MOUSE_LEFT )
		return;

	PostActionSignal( new KeyValues("ItemPanelMouseDoublePressed") );

	// audible feedback
	const char *soundFilename = "ui/buttonclickrelease.wav";

	if ( m_bUseItemSounds )
	{
		CEconItemView *item = GetItem();
		if ( item )
		{
			soundFilename = item->GetDefinitionString( "mouse_double_pressed_sound", "ui/item_default_drop.wav" );
		}
	}

	vgui::surface()->PlaySound( soundFilename );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CItemModelPanel::OnCursorMoved( int x, int y )
{
	if ( !m_bClickable )
		return;

	// Add our own xpos/ypos offset
	int iXPos;
	int iYPos;
	GetPos( iXPos, iYPos );
	PostActionSignal( new KeyValues("ItemPanelCursorMoved", "x", x + iXPos, "y", y + iYPos) );
}

void CItemModelPanel::OnKeyCodePressed( vgui::KeyCode code )
{
	BaseClass::OnKeyCodePressed( code );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CItemModelPanel::OnCommand( const char *command )
{
	if ( FStrEq( command, "sellitem" ) )
	{
		if ( HasItem() && steamapicontext && steamapicontext->SteamFriends() && steamapicontext->SteamUtils() )
		{
			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, GetItem()->GetItemID() );
			steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( szURL );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CItemModelPanel::UpdateEquippedLabel( void )
{
	if ( !m_pItemEquippedLabel )
		return;

	if ( IsGreyedOut() )
	{
		m_pItemEquippedLabel->SetFgColor( Color(96,96,96,255) );
	}
	else
	{
		m_pItemEquippedLabel->SetFgColor( Color(200,80,60,255) );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CItemModelPanel::SetSkin( int iSkin )
{
	if ( m_pModelPanel )
	{
		m_pModelPanel->SetSkin( iSkin );
	}
}


itempanel_tooltippos_t g_iTooltipStrategies[NUM_IPTTP_STRATEGIES][NUM_POSITIONS_PER_STRATEGY] =
{
	{ IPTTP_LEFT, IPTTP_LEFT_CENTERED, IPTTP_ABOVE, IPTTP_BELOW, IPTTP_RIGHT_CENTERED, IPTTP_RIGHT },	// IPTTP_LEFT_SIDE
	{ IPTTP_RIGHT, IPTTP_RIGHT_CENTERED, IPTTP_ABOVE, IPTTP_BELOW, IPTTP_LEFT_CENTERED, IPTTP_LEFT },	// IPTTP_RIGHT_SIDE
	{ IPTTP_ABOVE, IPTTP_LEFT_CENTERED, IPTTP_RIGHT_CENTERED, IPTTP_LEFT, IPTTP_RIGHT, IPTTP_ABOVE },	// IPTTP_TOP_SIDE
	{ IPTTP_BELOW, IPTTP_LEFT_CENTERED, IPTTP_RIGHT_CENTERED, IPTTP_LEFT, IPTTP_RIGHT, IPTTP_ABOVE },	// IPTTP_BOTTOM_SIDE
};

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CItemModelPanelToolTip::CItemModelPanelToolTip( vgui::Panel *parent, const char *text ) 
: vgui::BaseTooltip( parent, text )
, m_pMouseOverItemPanel( NULL )
, m_iPositioningStrategy( IPTTP_BOTTOM_SIDE )
{
	m_hCurrentPanel = NULL;
	SetTooltipDelay( 100 );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CItemModelPanelToolTip::GetPosition( itempanel_tooltippos_t iTooltipPosition, CItemModelPanel *pItemPanel, int iItemX, int iItemY, int *iXPos, int *iYPos )
{
	switch ( iTooltipPosition )
	{
	case IPTTP_LEFT:
		*iXPos = (iItemX - m_pMouseOverItemPanel->GetWide() + XRES(18));
		*iYPos = iItemY - YRES(7);
		break;
	case IPTTP_RIGHT: 
		*iXPos = (iItemX + pItemPanel->GetWide() - XRES(20));
		*iYPos = iItemY - YRES(7);
		break;
	case IPTTP_LEFT_CENTERED:
		*iXPos = (iItemX - m_pMouseOverItemPanel->GetWide()) - XRES(4);
		*iYPos = (iItemY - (m_pMouseOverItemPanel->GetTall() * 0.5));
		break;
	case IPTTP_RIGHT_CENTERED:
		*iXPos = (iItemX + pItemPanel->GetWide()) + XRES(4);
		*iYPos = (iItemY - (m_pMouseOverItemPanel->GetTall() * 0.5));
		break;
	case IPTTP_ABOVE:
		*iXPos = (iItemX + (pItemPanel->GetWide() * 0.5)) - (m_pMouseOverItemPanel->GetWide() * 0.5);
		*iYPos = (iItemY - m_pMouseOverItemPanel->GetTall() - YRES(4));
		break;
	case IPTTP_BELOW:
		*iXPos = (iItemX + (pItemPanel->GetWide() * 0.5)) - (m_pMouseOverItemPanel->GetWide() * 0.5);
		*iYPos = (iItemY + pItemPanel->GetTall() + YRES(4));
		break;
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CItemModelPanelToolTip::ValidatePosition( CItemModelPanel *pItemPanel, int iItemX, int iItemY, int *iXPos, int *iYPos )
{
	bool bSucceeded = true;

	// Make sure the popup stays onscreen.
	if ( *iXPos < 0 )
	{
		*iXPos = 0;
	}
	else if ( (*iXPos + m_pMouseOverItemPanel->GetWide()) > m_pParentPanel->GetWide() )
	{
		int iXPosNew = m_pParentPanel->GetWide() - m_pMouseOverItemPanel->GetWide();
		// make sure it is still on the screen
		if ( iXPosNew >= 0 )
		{
			*iXPos = iXPosNew;
		}
		else
		{
			bSucceeded = false;
		}
	}

	if ( *iYPos < 0 )
	{
		*iYPos = 0;
	}
	else if ( (*iYPos + m_pMouseOverItemPanel->GetTall() + YRES(32)) > m_pParentPanel->GetTall() )
	{
		// Move it up above our item
		int iYPosNew = iItemY - m_pMouseOverItemPanel->GetTall() - YRES(4);
		// make sure it is still on the screen
		if ( iYPosNew >= 0 )
		{
			*iYPos = iYPosNew;
		}
		else
		{
			bSucceeded = false;
		}
	}

	if ( bSucceeded )
	{
		// We also fail if moving it to keep it on screen moved it over the item panel itself
		Vector2D vecToolTipMin, vecToolTipMax, vecItemMin, vecItemMax;
		vecToolTipMin.x = *iXPos;
		vecToolTipMin.y = *iYPos;
		vecToolTipMax.x = vecToolTipMin.x + m_pMouseOverItemPanel->GetWide();
		vecToolTipMax.y = vecToolTipMin.y + m_pMouseOverItemPanel->GetTall();

		vecItemMin.x = iItemX;
		vecItemMin.y = iItemY;
		vecItemMax.x = vecItemMin.x + m_hCurrentPanel->GetWide();
		vecItemMax.y = vecItemMin.y + m_hCurrentPanel->GetTall();
		
		bSucceeded = !( vecToolTipMin.x < vecItemMax.x && vecToolTipMax.x > vecItemMin.x &&	vecToolTipMin.y < vecItemMax.y && vecToolTipMax.y > vecItemMin.y );
	}

	return bSucceeded;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CItemModelPanelToolTip::PerformLayout() 
{
	BaseClass::PerformLayout();

	if ( !ShouldLayout() )
		return;

	_isDirty = false;

	CItemModelPanel *pItemPanel = m_hCurrentPanel.Get();
	if ( m_pMouseOverItemPanel && pItemPanel ) 
	{		
		CEconItemView *pItem = pItemPanel->GetItem();
		if ( pItem && pItemPanel->ShouldShowTooltip() /*&& !IsIgnoringItemPanelEnters()*/ )
		{
			m_pMouseOverItemPanel->SetGreyedOut( pItemPanel->GetGreyedOutReason() );
			m_pMouseOverItemPanel->SetItem( pItem );
			m_pMouseOverItemPanel->DirtyDescription(); // Force rebuilding the description when we first display
			m_pMouseOverItemPanel->UpdateDescription();
			m_pMouseOverItemPanel->HideContainedItemPanel();
			m_pMouseOverItemPanel->InvalidateLayout(true);

			int x,y;

			// If the panel is somewhere in a derived class, we need to get its position in our space
			if ( pItemPanel->GetParent() != m_pMouseOverItemPanel->GetParent() )
			{
				int iItemAbsX, iItemAbsY;
				vgui::ipanel()->GetAbsPos( pItemPanel->GetVPanel(), iItemAbsX, iItemAbsY );
				int iParentAbsX, iParentAbsY;
				vgui::ipanel()->GetAbsPos( m_pMouseOverItemPanel->GetParent()->GetVPanel(), iParentAbsX, iParentAbsY );

				x = (iItemAbsX - iParentAbsX);
				y = (iItemAbsY - iParentAbsY);
			}
			else
			{
				pItemPanel->GetPos( x, y );
			}

			int iXPos = 0;
			int iYPos = 0;

			// Loop through the positions in our strategy, and hope we find a valid spot
			for ( int i = 0; i < NUM_POSITIONS_PER_STRATEGY; i++ )
			{
				itempanel_tooltippos_t iPos = g_iTooltipStrategies[m_iPositioningStrategy][i];
				GetPosition( iPos, pItemPanel, x, y, &iXPos, &iYPos );

				if ( ValidatePosition( pItemPanel, x, y, &iXPos, &iYPos ) )
					break;
			}

			m_pMouseOverItemPanel->SetPos( iXPos, iYPos );
			m_pMouseOverItemPanel->SetVisible( true );			
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CItemModelPanelToolTip::ShowTooltip( Panel *currentPanel ) 
{ 
	if ( m_pMouseOverItemPanel && currentPanel != m_hCurrentPanel.Get() ) 
	{
		CItemModelPanel *pItemPanel = assert_cast<CItemModelPanel *>(currentPanel);
		m_hCurrentPanel.Set( pItemPanel );
		pItemPanel->PostActionSignal( new KeyValues("ItemPanelEntered") );
		vgui::surface()->PlaySound( "ui/item_info_mouseover.wav" );

		m_pMouseOverItemPanel->HideContainedItemPanel();
	}
	BaseClass::ShowTooltip( currentPanel );	
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CItemModelPanelToolTip::HideTooltip() 
{
	if ( m_pMouseOverItemPanel ) 
	{
		m_pMouseOverItemPanel->SetVisible( false ); 
	}

	if ( m_hCurrentPanel )
	{
		m_hCurrentPanel.Get()->PostActionSignal( new KeyValues("ItemPanelExited") );
		m_hCurrentPanel = NULL;
	}
}