1HEADmaster

1 files changed, 1625 insertions, 0 deletions

diff --git a/vgui2/matsys_controls/baseassetpicker.cpp b/vgui2/matsys_controls/baseassetpicker.cpp
new file mode 100644
index 0000000..99e6eca
--- /dev/null
+++ b/vgui2/matsys_controls/baseassetpicker.cpp
@@ -0,0 +1,1625 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "filesystem.h"
+#include "matsys_controls/baseassetpicker.h"
+#include "tier1/KeyValues.h"
+#include "tier1/utlntree.h"
+#include "tier1/utlrbtree.h"
+#include "vgui_controls/ListPanel.h"
+#include "vgui_controls/TextEntry.h"
+#include "vgui_controls/ComboBox.h"
+#include "vgui_controls/Button.h"
+#include "vgui_controls/Splitter.h"
+#include "vgui_controls/TreeView.h"
+#include "vgui_controls/ImageList.h"
+#include "vgui_controls/CheckButton.h"
+#include "vgui/ISurface.h"
+#include "vgui/IInput.h"
+#include "vgui/IVGui.h"
+#include "vgui/Cursor.h"
+
+
+using namespace vgui;
+
+
+#define ASSET_LIST_DIRECTORY_INITIAL_SEARCH_TIME 0.25f
+#define ASSET_LIST_DIRECTORY_SEARCH_TIME 0.025f
+
+
+//-----------------------------------------------------------------------------
+// sorting function, should return true if node1 should be displayed before node2
+//-----------------------------------------------------------------------------
+bool AssetTreeViewSortFunc( KeyValues *node1, KeyValues *node2 )
+{
+	const char *pDir1 = node1->GetString( "text", NULL );
+	const char *pDir2 = node2->GetString( "text", NULL );
+	return Q_stricmp( pDir1, pDir2 ) < 0;
+}
+
+
+//-----------------------------------------------------------------------------
+//
+// Tree view for assets
+//
+//-----------------------------------------------------------------------------
+class CAssetTreeView : public vgui::TreeView
+{
+	DECLARE_CLASS_SIMPLE( CAssetTreeView, vgui::TreeView );
+
+public:
+	CAssetTreeView( vgui::Panel *parent, const char *name, const char *pRootFolderName, const char *pRootDir );
+
+	// Inherited from base classes
+	virtual void GenerateChildrenOfNode( int itemIndex );
+	virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
+
+	// Opens and selects the root folder
+	void OpenRoot();
+
+	// Purpose: Refreshes the active file list
+	void RefreshFileList();
+
+	// Adds a subdirectory
+	DirHandle_t GetRootDirectory( );
+	DirHandle_t AddSubDirectory( DirHandle_t hParent, const char *pDirName );
+	void ClearDirectories();
+
+	// Selects a folder
+	void SelectFolder( const char *pSubDir, const char *pPath );
+
+private:
+	// Allocates the root node
+	void AllocateRootNode( );
+
+	// Purpose: Refreshes the active file list
+	DirHandle_t RefreshTreeViewItem( int nItemIndex );
+
+	// Sets an item to be colored as if its a menu
+	void SetItemColorForDirectories( int nItemID );
+
+	// Add a directory into the treeview
+	void AddDirectoryToTreeView( int nParentItemIndex, const char *pFullParentPath, DirHandle_t hPath );
+
+	// Selects an item in the tree
+	bool SelectFolder_R( int nItemID, const char *pPath );
+
+	CUtlString m_RootFolderName;
+	CUtlString m_RootDirectory;
+	vgui::ImageList m_Images;
+	CUtlNTree< CUtlString, DirHandle_t > m_DirectoryStructure;
+};
+
+
+//-----------------------------------------------------------------------------
+// Constructor
+//-----------------------------------------------------------------------------
+CAssetTreeView::CAssetTreeView( Panel *pParent, const char *pName, const char *pRootFolderName, const char *pRootDir ) : BaseClass(pParent, pName), m_Images( false )
+{
+	SetSortFunc( AssetTreeViewSortFunc );
+
+	m_RootFolderName = pRootFolderName;
+	m_RootDirectory = pRootDir;
+	AllocateRootNode();
+
+	// build our list of images
+	m_Images.AddImage( scheme()->GetImage( "resource/icon_folder", false ) );
+	SetImageList( &m_Images, false );
+
+	SETUP_PANEL( this );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Refreshes the active file list
+//-----------------------------------------------------------------------------
+void CAssetTreeView::OpenRoot()
+{
+	RemoveAll();
+
+	// add the base node
+	const char *pRootDir = m_DirectoryStructure[ m_DirectoryStructure.Root() ];
+	KeyValues *pkv = new KeyValues( "root" );
+	pkv->SetString( "text", m_RootFolderName.Get() );
+	pkv->SetInt( "root", 1 );
+	pkv->SetInt( "expand", 1 );
+	pkv->SetInt( "dirHandle", m_DirectoryStructure.Root() );
+	pkv->SetString( "path", pRootDir );
+	int iRoot = AddItem( pkv, GetRootItemIndex() );
+	pkv->deleteThis();
+	ExpandItem( iRoot, true );
+}
+
+
+//-----------------------------------------------------------------------------
+// Allocates the root node
+//-----------------------------------------------------------------------------
+void CAssetTreeView::AllocateRootNode( )
+{
+	DirHandle_t hRoot = m_DirectoryStructure.Alloc();
+	m_DirectoryStructure.SetRoot( hRoot );
+	m_DirectoryStructure[hRoot] = m_RootDirectory;
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds a subdirectory (maintains sorted order)
+//-----------------------------------------------------------------------------
+DirHandle_t CAssetTreeView::GetRootDirectory( )
+{
+	return m_DirectoryStructure.Root();
+}
+
+DirHandle_t CAssetTreeView::AddSubDirectory( DirHandle_t hParent, const char *pDirName )
+{
+	DirHandle_t hSubdir = m_DirectoryStructure.Alloc();
+	m_DirectoryStructure[hSubdir] = pDirName;
+	m_DirectoryStructure[hSubdir].ToLower();
+
+	DirHandle_t hChild = m_DirectoryStructure.FirstChild( hParent );
+	m_DirectoryStructure.LinkChildBefore( hParent, hChild, hSubdir );
+
+	return hSubdir;
+}
+
+void CAssetTreeView::ClearDirectories()
+{
+	m_DirectoryStructure.RemoveAll();
+	AllocateRootNode();
+}
+
+
+//-----------------------------------------------------------------------------
+// Sets an item to be colored as if its a menu
+//-----------------------------------------------------------------------------
+void CAssetTreeView::SetItemColorForDirectories( int nItemID )
+{
+	// mark directories in orange
+	SetItemFgColor( nItemID, Color(224, 192, 0, 255) );
+}
+
+
+//-----------------------------------------------------------------------------
+// Add a directory into the treeview
+//-----------------------------------------------------------------------------
+void CAssetTreeView::AddDirectoryToTreeView( int nParentItemIndex, const char *pFullParentPath, DirHandle_t hPath )
+{
+	const char *pDirName = m_DirectoryStructure[hPath].Get();
+	KeyValues *kv = new KeyValues( "node", "text", pDirName );
+
+	char pFullPath[MAX_PATH];
+	Q_snprintf( pFullPath, sizeof( pFullPath ), "%s/%s", pFullParentPath, pDirName );
+	Q_FixSlashes( pFullPath );
+	Q_strlower( pFullPath );
+	bool bHasSubdirectories = m_DirectoryStructure.FirstChild( hPath ) != m_DirectoryStructure.InvalidIndex();
+	kv->SetString( "path", pFullPath );
+	kv->SetInt( "expand", bHasSubdirectories );
+	kv->SetInt( "image", 0 );
+	kv->SetInt( "dirHandle", hPath );
+
+	int nItemID = AddItem( kv, nParentItemIndex );
+	kv->deleteThis();
+
+	// mark directories in orange
+	SetItemColorForDirectories( nItemID );
+}
+
+
+//-----------------------------------------------------------------------------
+// override to incremental request and show p4 directories
+//-----------------------------------------------------------------------------
+void CAssetTreeView::GenerateChildrenOfNode( int nItemIndex )
+{
+	KeyValues *pkv = GetItemData( nItemIndex );
+
+	const char *pFullParentPath = pkv->GetString( "path", NULL );
+	if ( !pFullParentPath )
+		return;
+
+	DirHandle_t hPath = (DirHandle_t)pkv->GetInt( "dirHandle", m_DirectoryStructure.InvalidIndex() );
+	if ( hPath == m_DirectoryStructure.InvalidIndex() )
+		return;
+
+	DirHandle_t hChild = m_DirectoryStructure.FirstChild( hPath );
+	while ( hChild != m_DirectoryStructure.InvalidIndex() )
+	{
+		AddDirectoryToTreeView( nItemIndex, pFullParentPath, hChild );
+		hChild = m_DirectoryStructure.NextSibling( hChild );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Refreshes the active file list
+//-----------------------------------------------------------------------------
+DirHandle_t CAssetTreeView::RefreshTreeViewItem( int nItemIndex )
+{
+	if ( nItemIndex < 0 )
+		return m_DirectoryStructure.InvalidIndex();
+
+	// Make sure the expand icons are set correctly
+	KeyValues *pkv = GetItemData( nItemIndex );
+	DirHandle_t hPath = (DirHandle_t)pkv->GetInt( "dirHandle", m_DirectoryStructure.InvalidIndex() );
+	const char *pFullParentPath = pkv->GetString( "path", NULL );
+	bool bHasSubdirectories = m_DirectoryStructure.FirstChild( hPath ) != m_DirectoryStructure.InvalidIndex();
+	if ( bHasSubdirectories != ( pkv->GetInt( "expand" ) != 0 ) )
+	{
+		pkv->SetInt( "expand", bHasSubdirectories );
+		ModifyItem( nItemIndex, pkv );
+	}
+	bool bIsExpanded = IsItemExpanded( nItemIndex );
+	if ( !bIsExpanded )
+		return hPath;
+
+	// Check all children + build a list of children we've already got
+	int nChildCount = GetNumChildren( nItemIndex );
+	DirHandle_t *pFoundHandles = (DirHandle_t*)_alloca( nChildCount * sizeof(DirHandle_t) );
+	memset( pFoundHandles, 0xFF, nChildCount * sizeof(DirHandle_t) );
+	for ( int i = 0; i < nChildCount; ++i )
+	{
+		int nChildItemIndex = GetChild( nItemIndex, i );
+		pFoundHandles[i] = RefreshTreeViewItem( nChildItemIndex );
+	}
+
+	// Check directory structure to see if other directories were added
+	DirHandle_t hChild = m_DirectoryStructure.FirstChild( hPath );
+	for ( ; hChild != m_DirectoryStructure.InvalidIndex(); hChild = m_DirectoryStructure.NextSibling( hChild ) )
+	{
+		// Search for existence of this child already
+		bool bFound = false;
+		for ( int j = 0; j < nChildCount; ++j )
+		{
+			if ( pFoundHandles[j] == hChild )
+			{
+				pFoundHandles[j] = pFoundHandles[nChildCount-1];
+				--nChildCount;
+				bFound = true;
+				break;
+			}
+		}
+
+		if ( bFound )
+			continue;
+
+		// Child is new, add it
+		AddDirectoryToTreeView( nItemIndex, pFullParentPath, hChild );
+	}
+
+	return hPath;
+}
+
+void CAssetTreeView::RefreshFileList()
+{
+	// Make sure the expand icons are set correctly
+	RefreshTreeViewItem( GetRootItemIndex() );
+	InvalidateLayout();
+}
+
+
+//-----------------------------------------------------------------------------
+// Selects a folder
+//-----------------------------------------------------------------------------
+bool CAssetTreeView::SelectFolder_R( int nItemID, const char *pPath )
+{
+	if ( nItemID < 0 )
+		return false;
+
+	KeyValues *kv = GetItemData( nItemID );
+	const char *pTestPath = kv->GetString( "path" );
+	if ( !Q_stricmp( pTestPath, pPath ) )
+	{
+		AddSelectedItem( nItemID, true, false, true );
+		return true;
+	}
+
+	// Substring match..
+	CUtlString str = pTestPath;
+	str += '\\';
+	if ( Q_strnicmp( str, pPath, str.Length() ) )
+		return false;
+
+	ExpandItem( nItemID, true );
+
+	int nChildCount = GetNumChildren( nItemID );
+	for ( int i = 0; i < nChildCount; ++i )
+	{
+		int nChildItemID = GetChild( nItemID, i );
+		if ( SelectFolder_R( nChildItemID, pPath ) )
+			return true;
+	}
+	return false;
+}
+
+void CAssetTreeView::SelectFolder( const char *pSubDir, const char *pPath )
+{
+	char pTemp[MAX_PATH];
+	Q_snprintf( pTemp, sizeof(pTemp), "%s\\%s", pSubDir, pPath );
+	Q_StripTrailingSlash( pTemp );
+
+	int nItem = GetRootItemIndex();
+	SelectFolder_R( nItem, pTemp );
+}
+
+
+
+//-----------------------------------------------------------------------------
+// setup a smaller font
+//-----------------------------------------------------------------------------
+void CAssetTreeView::ApplySchemeSettings( IScheme *pScheme )
+{
+	BaseClass::ApplySchemeSettings( pScheme );
+	SetFont( pScheme->GetFont("DefaultSmall") );
+	SetFgColor( Color(216, 222, 211, 255) );
+}
+
+
+//-----------------------------------------------------------------------------
+//
+// Cache of asset data so we don't need to rebuild all the time
+//
+//-----------------------------------------------------------------------------
+DECLARE_POINTER_HANDLE( AssetList_t );
+#define ASSET_LIST_INVALID ((AssetList_t)(0xFFFF))
+
+
+class CAssetCache
+{
+public:
+	struct CachedAssetInfo_t
+	{
+		CUtlString m_AssetName;
+		int m_nModIndex;
+	};
+
+	struct ModInfo_t
+	{
+		CUtlString m_ModName;
+		CUtlString m_Path;
+	};
+
+	CAssetCache();
+
+	// Mod iteration
+	int ModCount() const;
+	const ModInfo_t& ModInfo( int nIndex ) const;
+	
+	// Building the mod list
+	void BuildModList();
+
+	AssetList_t FindAssetList( const char *pAssetType, const char *pSubDir, int nExtCount, const char **ppExt );
+	bool BeginAssetScan( AssetList_t hList, bool bForceRescan = false );
+	CAssetTreeView* GetFileTree( AssetList_t hList );
+	int GetAssetCount( AssetList_t hList ) const;
+	const CachedAssetInfo_t& GetAsset( AssetList_t hList, int nIndex ) const;
+
+	void AddAsset( AssetList_t hList, const CachedAssetInfo_t& info );
+
+	bool ContinueSearchForAssets( AssetList_t hList, float flDuration );
+
+private:
+	struct DirToCheck_t
+	{
+		CUtlString m_DirName;
+		DirHandle_t m_hDirHandle;
+	};
+
+	struct CachedAssetList_t
+	{
+		CachedAssetList_t() {}
+		CachedAssetList_t( const char *pSearchSubDir, int nExtCount, const char **ppSearchExt )	:
+			m_pSubDir( pSearchSubDir, Q_strlen( pSearchSubDir ) + 1 )
+		{
+			m_Ext.AddMultipleToTail( nExtCount, ppSearchExt );
+		}
+ 		CachedAssetList_t( const CachedAssetList_t& )
+		{
+			// Only used during insertion; do nothing
+		}
+
+		CUtlVector< CachedAssetInfo_t > m_AssetList;
+		CAssetTreeView *m_pFileTree;
+
+		CUtlString m_pSubDir;
+		CUtlVector< const char * > m_Ext;
+
+		CUtlLinkedList< DirToCheck_t > m_DirectoriesToCheck;
+		FileFindHandle_t m_hFind;
+		bool m_bAssetScanComplete;
+	};
+
+private:
+	bool AddFilesInDirectory( CachedAssetList_t& list, const char *pStartingFile, const char *pFilePath, DirHandle_t hDirHandle, float flStartTime, float flDuration );
+	bool DoesExtensionMatch( CachedAssetList_t& list, const char *pFileName );
+	void AddAssetToList( CachedAssetList_t& list, const char *pAssetName, int nModIndex );
+
+private:
+	// List of known mods
+	CUtlVector< ModInfo_t > m_ModList;
+
+	// List of cached assets
+	CUtlRBTree< CachedAssetList_t > m_CachedAssets;
+
+	// Have we built the mod list?
+	bool m_bBuiltModList;
+
+	static bool CachedAssetLessFunc( const CachedAssetList_t& src1, const CachedAssetList_t& src2 );
+};
+
+
+//-----------------------------------------------------------------------------
+// Static instance of the asset cache
+//-----------------------------------------------------------------------------
+static CAssetCache s_AssetCache;
+
+
+//-----------------------------------------------------------------------------
+// Map sort func
+//-----------------------------------------------------------------------------
+bool CAssetCache::CachedAssetLessFunc( const CAssetCache::CachedAssetList_t& src1, const CAssetCache::CachedAssetList_t& src2 )
+{
+	int nRetVal = Q_stricmp( src1.m_pSubDir, src2.m_pSubDir ) > 0;
+	if ( nRetVal != 0 )
+		return nRetVal > 0;
+
+	int nCount = src1.m_Ext.Count();
+	int nDiff = nCount - src2.m_Ext.Count();
+	if ( nDiff != 0 )
+		return nDiff > 0;
+
+	for ( int i = 0; i < nCount; ++i )
+	{
+		nRetVal = Q_stricmp( src1.m_Ext[i], src2.m_Ext[i] );
+		if ( nRetVal != 0 )
+			return nRetVal > 0;
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Constructor
+//-----------------------------------------------------------------------------
+CAssetCache::CAssetCache() : m_CachedAssets( 0, 0, CachedAssetLessFunc )
+{
+	m_bBuiltModList = false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Mod iteration
+//-----------------------------------------------------------------------------
+int CAssetCache::ModCount() const
+{
+	return m_ModList.Count();
+}
+
+const CAssetCache::ModInfo_t& CAssetCache::ModInfo( int nIndex ) const
+{
+	return m_ModList[nIndex];
+}
+
+
+//-----------------------------------------------------------------------------
+// Building the mod list
+//-----------------------------------------------------------------------------
+void CAssetCache::BuildModList()
+{
+	if ( m_bBuiltModList )
+		return;
+
+	m_bBuiltModList = true;
+
+	m_ModList.RemoveAll();
+
+	// Add all mods
+	int nLen = g_pFullFileSystem->GetSearchPath( "GAME", false, NULL, 0 );
+	char *pSearchPath = (char*)stackalloc( nLen * sizeof(char) );
+	g_pFullFileSystem->GetSearchPath( "GAME", false, pSearchPath, nLen );
+	char *pPath = pSearchPath;
+	while( pPath )
+	{
+		char *pSemiColon = strchr( pPath, ';' );
+		if ( pSemiColon )
+		{
+			*pSemiColon = 0;
+		}
+
+		Q_StripTrailingSlash( pPath );
+		Q_FixSlashes( pPath );
+
+		char pModName[ MAX_PATH ];
+		Q_FileBase( pPath, pModName, sizeof( pModName ) );
+
+		// Always start in an asset-specific directory
+//		char pAssetPath[MAX_PATH];
+//		Q_snprintf( pAssetPath, MAX_PATH, "%s\\%s", pPath, m_pAssetSubDir );
+//		Q_FixSlashes( pPath );
+
+		int i = m_ModList.AddToTail( );
+		m_ModList[i].m_ModName.Set( pModName );
+		m_ModList[i].m_Path.Set( pPath );
+
+		pPath = pSemiColon ? pSemiColon + 1 : NULL;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Adds an asset to the list of assets of this type
+//-----------------------------------------------------------------------------
+void CAssetCache::AddAssetToList( CachedAssetList_t& list, const char *pAssetName, int nModIndex )
+{
+	int i = list.m_AssetList.AddToTail( );
+	CachedAssetInfo_t& info = list.m_AssetList[i];
+	info.m_AssetName.Set( pAssetName );
+	info.m_nModIndex = nModIndex;
+}
+
+
+//-----------------------------------------------------------------------------
+// Extension matches?
+//-----------------------------------------------------------------------------
+bool CAssetCache::DoesExtensionMatch( CachedAssetList_t& info, const char *pFileName )
+{
+	char pChildExt[MAX_PATH];
+	Q_ExtractFileExtension( pFileName, pChildExt, sizeof(pChildExt) );
+
+	// Check the extension matches
+	int nCount = info.m_Ext.Count();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		if ( !Q_stricmp( info.m_Ext[i], pChildExt ) )
+			return true;
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Recursively add all files matching the wildcard under this directory
+//-----------------------------------------------------------------------------
+bool CAssetCache::AddFilesInDirectory( CachedAssetList_t& list, const char *pStartingFile, const char *pFilePath, DirHandle_t hCurrentDir, float flStartTime, float flDuration )
+{
+	// Indicates no files found
+	if ( list.m_hFind == FILESYSTEM_INVALID_FIND_HANDLE )
+		return true;
+
+	// generate children
+	// add all the items
+	int nModCount = m_ModList.Count();
+	int nSubDirLen = list.m_pSubDir ? Q_strlen(list.m_pSubDir) : 0;
+	const char *pszFileName	= pStartingFile;
+	while ( pszFileName )
+	{
+		char pRelativeChildPath[MAX_PATH];
+		Q_snprintf( pRelativeChildPath, MAX_PATH, "%s\\%s", pFilePath, pszFileName );
+
+		if ( g_pFullFileSystem->FindIsDirectory( list.m_hFind ) )
+		{
+			// If .svn is in the name, don't add this directory!!
+			if ( strstr (pszFileName, ".svn") )
+			{
+				pszFileName = g_pFullFileSystem->FindNext( list.m_hFind );
+				continue;
+			}
+
+			if ( Q_strnicmp( pszFileName, ".", 2 ) && Q_strnicmp( pszFileName, "..", 3 ) )
+			{
+				DirHandle_t hDirHandle = list.m_pFileTree->AddSubDirectory( hCurrentDir, pszFileName );
+				int i = list.m_DirectoriesToCheck.AddToTail();
+				list.m_DirectoriesToCheck[i].m_DirName = pRelativeChildPath;
+				list.m_DirectoriesToCheck[i].m_hDirHandle = hDirHandle;
+			}
+		}
+		else
+		{
+			// Check the extension matches
+			if ( DoesExtensionMatch( list, pszFileName ) )
+			{
+				char pFullAssetPath[MAX_PATH];
+				g_pFullFileSystem->RelativePathToFullPath( pRelativeChildPath, "GAME", pFullAssetPath, sizeof(pFullAssetPath) );
+
+				int nModIndex = -1;
+				for ( int i = 0; i < nModCount; ++i )
+				{
+					if ( !Q_strnicmp( pFullAssetPath, m_ModList[i].m_Path, m_ModList[i].m_Path.Length() ) )
+					{
+						nModIndex = i;
+						break;
+					}
+				}
+
+				if ( nModIndex >= 0 )
+				{
+					// Strip 'subdir/' prefix
+					char *pAssetName = pRelativeChildPath;
+					if ( list.m_pSubDir )
+					{
+						if ( !Q_strnicmp( list.m_pSubDir, pAssetName, nSubDirLen ) )
+						{
+							if ( pAssetName[nSubDirLen] == '\\' )
+							{
+								pAssetName += nSubDirLen + 1;
+							}
+						}
+					}
+					strlwr( pAssetName );
+
+					AddAssetToList( list, pAssetName, nModIndex );
+				}
+			}
+		}
+
+		// Don't let the search go for too long at a time
+		if ( Plat_FloatTime() - flStartTime >= flDuration )
+			return false;
+
+		pszFileName = g_pFullFileSystem->FindNext( list.m_hFind );
+	}
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Recursively add all files matching the wildcard under this directory
+//-----------------------------------------------------------------------------
+bool CAssetCache::ContinueSearchForAssets( AssetList_t hList, float flDuration )
+{
+	CachedAssetList_t& list = m_CachedAssets[ (int)hList ];
+
+	float flStartTime = Plat_FloatTime();
+	while ( list.m_DirectoriesToCheck.Count() )
+	{
+		const char *pFilePath = list.m_DirectoriesToCheck[ list.m_DirectoriesToCheck.Head() ].m_DirName;
+		DirHandle_t hCurrentDir = list.m_DirectoriesToCheck[ list.m_DirectoriesToCheck.Head() ].m_hDirHandle;
+
+		const char *pStartingFile;
+		if ( list.m_hFind == FILESYSTEM_INVALID_FIND_HANDLE )
+		{
+			char pSearchString[MAX_PATH];
+			Q_snprintf( pSearchString, MAX_PATH, "%s\\*", pFilePath );
+
+			// get the list of files
+			pStartingFile = g_pFullFileSystem->FindFirstEx( pSearchString, "GAME", &list.m_hFind );
+		}
+		else
+		{
+			pStartingFile = g_pFullFileSystem->FindNext( list.m_hFind );
+		}
+
+		if ( !AddFilesInDirectory( list, pStartingFile, pFilePath, hCurrentDir, flStartTime, flDuration ) )
+			return false;
+
+		g_pFullFileSystem->FindClose( list.m_hFind );
+		list.m_hFind = FILESYSTEM_INVALID_FIND_HANDLE;
+		list.m_DirectoriesToCheck.Remove( list.m_DirectoriesToCheck.Head() );
+	}
+	list.m_bAssetScanComplete = true;
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Asset cache iteration
+//-----------------------------------------------------------------------------
+bool CAssetCache::BeginAssetScan( AssetList_t hList, bool bForceRescan )
+{
+	CachedAssetList_t& list = m_CachedAssets[ (int)hList ];
+	if ( bForceRescan )
+	{
+		list.m_bAssetScanComplete = false;
+		if ( list.m_hFind != FILESYSTEM_INVALID_FIND_HANDLE )
+		{
+			g_pFullFileSystem->FindClose( list.m_hFind );
+			list.m_hFind = FILESYSTEM_INVALID_FIND_HANDLE;
+		}
+		list.m_DirectoriesToCheck.RemoveAll();
+	}
+
+	if ( list.m_bAssetScanComplete )
+		return false;
+
+	// This case occurs if we stopped the picker previously while in the middle of a scan
+	if ( list.m_hFind != FILESYSTEM_INVALID_FIND_HANDLE )
+		return true;
+
+	list.m_AssetList.RemoveAll();
+	list.m_pFileTree->ClearDirectories();
+
+	// Add all files, determine which mod they are in.
+	int i = list.m_DirectoriesToCheck.AddToTail();
+	list.m_DirectoriesToCheck[i].m_DirName = list.m_pSubDir;
+	list.m_DirectoriesToCheck[i].m_hDirHandle = list.m_pFileTree->GetRootDirectory();
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Asset cache iteration
+//-----------------------------------------------------------------------------
+AssetList_t CAssetCache::FindAssetList( const char *pAssetType, const char *pSubDir, int nExtCount, const char **ppExt )
+{
+	CachedAssetList_t search( pSubDir, nExtCount, ppExt );
+	int nIndex = m_CachedAssets.Find( search );
+	if ( nIndex == m_CachedAssets.InvalidIndex() )
+	{
+		nIndex = m_CachedAssets.Insert( search );
+		CachedAssetList_t &list = m_CachedAssets[nIndex];
+		list.m_pSubDir = pSubDir;
+		list.m_Ext.AddMultipleToTail( nExtCount, ppExt );
+		list.m_hFind = FILESYSTEM_INVALID_FIND_HANDLE;
+		list.m_bAssetScanComplete = false;
+		list.m_pFileTree = new CAssetTreeView( NULL, "FolderFilter", pAssetType, pSubDir );
+	}
+
+	return (AssetList_t)nIndex;
+}
+
+CAssetTreeView* CAssetCache::GetFileTree( AssetList_t hList )
+{
+	if ( hList == ASSET_LIST_INVALID )
+		return NULL;
+	return m_CachedAssets[ (int)hList ].m_pFileTree;
+}
+
+int CAssetCache::GetAssetCount( AssetList_t hList ) const
+{
+	if ( hList == ASSET_LIST_INVALID )
+		return 0;
+	return m_CachedAssets[ (int)hList ].m_AssetList.Count();
+}
+
+const CAssetCache::CachedAssetInfo_t& CAssetCache::GetAsset( AssetList_t hList, int nIndex ) const
+{
+	Assert( nIndex < GetAssetCount(hList) );
+	return m_CachedAssets[ (int)hList ].m_AssetList[ nIndex ];
+}
+
+
+
+//-----------------------------------------------------------------------------
+//
+// Base asset Picker
+//
+//-----------------------------------------------------------------------------
+
+
+//-----------------------------------------------------------------------------
+// Sort by asset name
+//-----------------------------------------------------------------------------
+static int __cdecl AssetBrowserSortFunc( vgui::ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 )
+{
+	bool bRoot1 = item1.kv->GetInt("root") != 0;
+	bool bRoot2 = item2.kv->GetInt("root") != 0;
+	if ( bRoot1 != bRoot2 )
+		return bRoot1 ? -1 : 1;
+	const char *pString1 = item1.kv->GetString("asset");
+	const char *pString2 = item2.kv->GetString("asset");
+	return Q_stricmp( pString1, pString2 );
+}
+
+static int __cdecl AssetBrowserModSortFunc( vgui::ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 )
+{
+	int nMod1 = item1.kv->GetInt("modIndex", -1);
+	int nMod2 = item2.kv->GetInt("modIndex", -1);
+	if ( nMod1 != nMod2 )
+		return nMod1 - nMod2;
+	return AssetBrowserSortFunc( pPanel, item1, item2 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Constructor
+//-----------------------------------------------------------------------------
+CBaseAssetPicker::CBaseAssetPicker( vgui::Panel *pParent, const char *pAssetType, 
+	const char *pExt, const char *pSubDir, const char *pTextType ) : 
+	BaseClass( pParent, "AssetPicker" )
+{
+	m_bBuiltAssetList = false;
+	m_pAssetType = pAssetType;
+	m_pAssetTextType = pTextType;
+	m_pAssetExt = pExt;
+	m_pAssetSubDir = pSubDir;
+	m_bFinishedAssetListScan = false;
+	m_bFirstAssetScan = false;
+	m_nMatchingAssets = 0;
+	m_bSubDirCheck = true;
+	m_hAssetList = ASSET_LIST_INVALID;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Destructor
+//-----------------------------------------------------------------------------
+CBaseAssetPicker::~CBaseAssetPicker()
+{
+	SaveUserConfig();
+
+	// Detach!
+	m_pFileTree->RemoveActionSignalTarget( this );
+	m_pFileTree->SetParent( (Panel*)NULL );
+	m_pFileTree = NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+// Creates standard controls
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::CreateStandardControls( vgui::Panel *pParent, bool bAllowMultiselect )
+{
+	int nExtCount = 1 + m_ExtraAssetExt.Count();
+	const char **ppExt = (const char **)_alloca( nExtCount * sizeof(const char *) );
+	ppExt[0] = m_pAssetExt;
+	if ( nExtCount > 1 )
+	{
+		memcpy( ppExt + 1, m_ExtraAssetExt.Base(), nExtCount - 1 );
+	}
+
+	m_hAssetList = s_AssetCache.FindAssetList( m_pAssetType, m_pAssetSubDir, nExtCount, ppExt );
+
+	m_pAssetSplitter = new vgui::Splitter( pParent, "AssetSplitter", SPLITTER_MODE_HORIZONTAL, 1 );
+	vgui::Panel *pSplitterTopSide = m_pAssetSplitter->GetChild( 0 );
+	vgui::Panel *pSplitterBottomSide = m_pAssetSplitter->GetChild( 1 );
+
+	// Combo box for mods
+	m_pModSelector = new ComboBox( pSplitterTopSide, "ModFilter", 5, false );
+	m_pModSelector->AddActionSignalTarget( this );
+
+	// Rescan button
+	m_pRescanButton = new Button( pSplitterTopSide, "RescanButton", "Rescan", this, "AssetRescan" );
+
+	// file browser tree controls
+	m_pFileTree = s_AssetCache.GetFileTree( m_hAssetList );
+	m_pFileTree->SetParent( pSplitterTopSide );
+	m_pFileTree->AddActionSignalTarget( this );
+
+	m_pSubDirCheck = new CheckButton( pSplitterTopSide, "SubDirCheck", "Check subfolders for files?" );
+	m_pSubDirCheck->SetSelected( true );
+	m_pSubDirCheck->SetEnabled( false );
+	m_pSubDirCheck->SetVisible( false );
+	m_pSubDirCheck->AddActionSignalTarget( this );
+
+	char pTemp[512];
+	Q_snprintf( pTemp, sizeof(pTemp), "No .%s files", m_pAssetExt );
+	m_pAssetBrowser = new vgui::ListPanel( pSplitterBottomSide, "AssetBrowser" );
+ 	m_pAssetBrowser->AddColumnHeader( 0, "mod", "Mod", 52, 0 );
+	m_pAssetBrowser->AddColumnHeader( 1, "asset", m_pAssetType, 128, ListPanel::COLUMN_RESIZEWITHWINDOW );
+    m_pAssetBrowser->SetSelectIndividualCells( false );
+    m_pAssetBrowser->SetMultiselectEnabled( bAllowMultiselect );
+	m_pAssetBrowser->SetEmptyListText( pTemp );
+ 	m_pAssetBrowser->SetDragEnabled( true );
+	m_pAssetBrowser->AddActionSignalTarget( this );
+	m_pAssetBrowser->SetSortFunc( 0, AssetBrowserModSortFunc );
+	m_pAssetBrowser->SetSortFunc( 1, AssetBrowserSortFunc );
+	m_pAssetBrowser->SetSortColumn( 1 );
+						 
+	// filter selection
+	m_pFilter = new TextEntry( pSplitterBottomSide, "FilterList" );
+	m_pFilter->AddActionSignalTarget( this );
+
+	// full path
+	m_pFullPath = new TextEntry( pSplitterBottomSide, "FullPath" );
+	m_pFullPath->SetEnabled( false );
+	m_pFullPath->SetEditable( false );
+
+	m_nCurrentModFilter = -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Reads user config settings
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::ApplyUserConfigSettings( KeyValues *pUserConfig )
+{
+	BaseClass::ApplyUserConfigSettings( pUserConfig );
+
+	// Populates the mod list names
+	RefreshAssetList();
+
+	const char *pFilter = pUserConfig->GetString( "filter", "" );
+	m_FolderFilter = pUserConfig->GetString( "folderfilter", "" );
+	const char *pMod = pUserConfig->GetString( "mod", "" );
+	SetFilter( pFilter );
+	m_nCurrentModFilter = -1;
+	if ( pMod && pMod[0] )
+	{
+		int nCount = s_AssetCache.ModCount();
+		for ( int i = 0; i < nCount; ++i )
+		{
+			const CAssetCache::ModInfo_t& modInfo = s_AssetCache.ModInfo( i );
+			if ( Q_stricmp( pMod, modInfo.m_ModName ) )
+				continue;
+
+			int nItemCount = m_pModSelector->GetItemCount();
+			for ( int j = 0; j < nItemCount; ++j )
+			{
+				int nItemID = m_pModSelector->GetItemIDFromRow( j );
+				KeyValues *kv = m_pModSelector->GetItemUserData( nItemID );
+				int nModIndex = kv->GetInt( "mod" );
+				if ( nModIndex == i )
+				{
+					m_nCurrentModFilter = i;
+					m_pModSelector->ActivateItem( nItemID );
+					break;
+				}
+			}
+			break;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: returns user config settings for this control
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::GetUserConfigSettings( KeyValues *pUserConfig )
+{
+	BaseClass::GetUserConfigSettings( pUserConfig );
+	pUserConfig->SetString( "filter", m_Filter );
+	pUserConfig->SetString( "folderfilter", m_FolderFilter );
+	pUserConfig->SetString( "mod", ( m_nCurrentModFilter >= 0 ) ? 
+		s_AssetCache.ModInfo( m_nCurrentModFilter ).m_ModName : "" );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: optimization, return true if this control has any user config settings
+//-----------------------------------------------------------------------------
+bool CBaseAssetPicker::HasUserConfigSettings()
+{
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Allows the picker to browse multiple asset types
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::AddExtension( const char *pExtension )
+{
+	m_ExtraAssetExt.AddToTail( pExtension );
+}
+
+
+//-----------------------------------------------------------------------------
+// Is multiselect enabled?
+//-----------------------------------------------------------------------------
+bool CBaseAssetPicker::IsMultiselectEnabled() const
+{
+	return m_pAssetBrowser->IsMultiselectEnabled(); 
+}
+
+
+//-----------------------------------------------------------------------------
+// Sets the initial selected asset
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::SetInitialSelection( const char *pAssetName )
+{
+	// This makes it so the background list filling code will automatically select this asset when it gets to it.
+	m_SelectedAsset = pAssetName;		
+								   
+	if ( pAssetName )
+	{	
+		// Sometimes we've already refreshed our list with a bunch of cached resources and the item is already in the list,
+		// so in that case just select it here.
+		int cnt = m_pAssetBrowser->GetItemCount();
+		for ( int i=0; i < cnt; i++ )
+		{
+			KeyValues *kv = m_pAssetBrowser->GetItem( i );
+			if ( !kv )
+				continue;
+			
+			const char *pTestAssetName = kv->GetString( "asset" );
+			if ( !pTestAssetName )
+				continue;
+				
+			if ( Q_stricmp( pTestAssetName, pAssetName ) == 0 )
+			{
+				m_pAssetBrowser->SetSelectedCell( i, 0 );
+				break;
+			}			
+		}
+	}
+}
+
+	
+//-----------------------------------------------------------------------------
+// Set/get the filter
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::SetFilter( const char *pFilter )
+{
+	m_Filter = pFilter;
+	m_pFilter->SetText( pFilter );
+}
+
+const char *CBaseAssetPicker::GetFilter()
+{
+	return m_Filter;
+}
+
+	
+//-----------------------------------------------------------------------------
+// Purpose: called to open
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::Activate()
+{
+	RefreshAssetList();
+	RequestFilterFocus();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::OnKeyCodePressed( KeyCode code )
+{
+	if (( code == KEY_UP ) || ( code == KEY_DOWN ) || ( code == KEY_PAGEUP ) || ( code == KEY_PAGEDOWN ))
+	{
+		KeyValues *pMsg = new KeyValues("KeyCodePressed", "code", code);
+		vgui::ipanel()->SendMessage( m_pAssetBrowser->GetVPanel(), pMsg, GetVPanel());
+		pMsg->deleteThis();
+	}
+	else
+	{
+		BaseClass::OnKeyCodePressed( code );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Is a particular asset visible?
+//-----------------------------------------------------------------------------
+bool CBaseAssetPicker::IsAssetVisible( int nAssetIndex )
+{
+	const CAssetCache::CachedAssetInfo_t& info = s_AssetCache.GetAsset( m_hAssetList, nAssetIndex );
+
+	// Filter based on active mod
+	int nModIndex = info.m_nModIndex;
+	if ( ( m_nCurrentModFilter >= 0 ) && ( m_nCurrentModFilter != nModIndex ) )
+		return false;
+
+	// Filter based on name
+	const char *pAssetName = info.m_AssetName;
+	if ( !Q_strcmp( pAssetName, m_SelectedAsset ) )
+		return true;
+
+	if ( m_Filter.Length() && !Q_stristr( pAssetName, m_Filter.Get() ) )
+		return false;
+
+	// Filter based on folder
+	if ( m_FolderFilter.Length() && Q_strnicmp( pAssetName, m_FolderFilter.Get(), m_FolderFilter.Length() ) )
+		return false;
+
+	// Filter based on subdirectory check
+	if ( !m_bSubDirCheck && strchr( pAssetName + m_FolderFilter.Length(), '\\' ) )
+		return false;
+
+	return true;
+}
+		
+
+//-----------------------------------------------------------------------------
+// Adds an asset from the cache to the list
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::AddAssetToList( int nAssetIndex )
+{
+	const CAssetCache::CachedAssetInfo_t& info = s_AssetCache.GetAsset( m_hAssetList, nAssetIndex );
+
+	bool bInRootDir = !strchr( info.m_AssetName, '\\' ) && !strchr( info.m_AssetName, '/' );
+
+	KeyValues *kv = new KeyValues( "node", "asset", info.m_AssetName );
+	kv->SetString( "mod", s_AssetCache.ModInfo( info.m_nModIndex ).m_ModName );
+	kv->SetInt( "modIndex", info.m_nModIndex );
+	kv->SetInt( "root", bInRootDir );
+	int nItemID = m_pAssetBrowser->AddItem( kv, 0, false, false );
+	kv->deleteThis();
+	
+	if ( m_pAssetBrowser->GetSelectedItemsCount() == 0 && !Q_strcmp( m_SelectedAsset, info.m_AssetName ) )
+	{
+		m_pAssetBrowser->SetSelectedCell( nItemID, 0 );
+	}
+
+	KeyValues *pDrag = new KeyValues( "drag", "text", info.m_AssetName );
+	if ( m_pAssetTextType )
+	{
+		pDrag->SetString( "texttype", m_pAssetTextType );
+	}
+	m_pAssetBrowser->SetItemDragData( nItemID, pDrag );
+
+	int i = m_AssetList.AddToTail( );
+	m_AssetList[i].m_nAssetIndex = nAssetIndex;
+	m_AssetList[i].m_nItemId = nItemID;
+
+	bool bIsVisible = IsAssetVisible( i );
+	m_pAssetBrowser->SetItemVisible( nItemID, bIsVisible );
+	if ( bIsVisible )
+	{
+		++m_nMatchingAssets;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Continues to build the asset list
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::OnTick()
+{
+	BaseClass::OnTick();
+
+	int nPreAssetCount = s_AssetCache.GetAssetCount( m_hAssetList );
+
+	// Stop getting called back once all assets have been found
+	float flTime = m_bFirstAssetScan ? ASSET_LIST_DIRECTORY_INITIAL_SEARCH_TIME : ASSET_LIST_DIRECTORY_SEARCH_TIME;
+	bool bFinished = s_AssetCache.ContinueSearchForAssets( m_hAssetList, flTime );
+
+	if ( m_bFirstAssetScan )
+	{
+		m_pFileTree->OpenRoot();
+	}
+	m_bFirstAssetScan = false;
+
+	int nPostAssetCount = s_AssetCache.GetAssetCount( m_hAssetList );
+	for ( int i = nPreAssetCount; i < nPostAssetCount; ++i )
+	{
+		AddAssetToList( i );
+	}
+
+	if ( bFinished )
+	{
+		vgui::ivgui()->RemoveTickSignal( GetVPanel() );
+		m_bFinishedAssetListScan = true;
+
+		// Copy the current folder filter.. this is necessary
+		// to finally select the folder loaded from the user config settings
+		// in the free view (since it's finally populated at this point)
+		// NOTE: if a user has changed the folder filter between startup
+		// and this point, this should still work since m_FolderFilter should be updated
+		m_pFileTree->SelectFolder( m_pAssetSubDir, m_FolderFilter );
+		RefreshAssetList( );
+		return;
+	}
+
+	UpdateAssetColumnHeader();
+}
+
+	
+//-----------------------------------------------------------------------------
+// Builds the Bsp name list
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::BuildAssetNameList( )
+{
+	if ( m_bBuiltAssetList )
+		return;
+
+	m_bBuiltAssetList = true;
+	m_nMatchingAssets = 0;
+	m_nCurrentModFilter = -1;
+
+	// Build the list of known mods if we haven't 
+	s_AssetCache.BuildModList();
+
+	m_pModSelector->RemoveAll();
+	m_pModSelector->AddItem( "All Mods", new KeyValues( "Mod", "mod", -1 ) );
+	int nModCount = s_AssetCache.ModCount();
+	for ( int i = 0; i < nModCount; ++i )
+	{
+		const char *pModName = s_AssetCache.ModInfo( i ).m_ModName;
+		m_pModSelector->AddItem( pModName, new KeyValues( "Mod", "mod", i ) );
+	}
+	m_pModSelector->ActivateItemByRow( 0 );
+
+	// If we've already read in
+	if ( s_AssetCache.BeginAssetScan( m_hAssetList ) )
+	{
+		m_bFirstAssetScan = true;
+		m_bFinishedAssetListScan = false;
+		vgui::ivgui()->AddTickSignal( GetVPanel(), 10 );
+	}
+	else
+	{
+		m_bFirstAssetScan = false;
+		m_bFinishedAssetListScan = true;
+	}
+
+	int nAssetCount = s_AssetCache.GetAssetCount( m_hAssetList );
+	for ( int i = 0; i < nAssetCount; ++i )
+	{
+		AddAssetToList( i );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Rescan assets
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::RescanAssets()
+{
+	m_pAssetBrowser->RemoveAll();
+	m_AssetList.RemoveAll();
+	s_AssetCache.BeginAssetScan( m_hAssetList, true );
+	m_bFirstAssetScan = true;
+	m_nMatchingAssets = 0;
+
+	if ( m_bFinishedAssetListScan )
+	{
+		m_bFinishedAssetListScan = false;
+		vgui::ivgui()->AddTickSignal( GetVPanel(), 10 );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns the mod path to the item index
+//-----------------------------------------------------------------------------
+const char *CBaseAssetPicker::GetModPath( int nModIndex )
+{
+	return s_AssetCache.ModInfo( nModIndex ).m_Path.Get();
+}
+
+
+//-----------------------------------------------------------------------------
+// Command handler
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::OnCommand( const char *pCommand )
+{
+	if ( !Q_stricmp( pCommand, "AssetRescan" ) )
+	{
+		RescanAssets();
+		return;
+	}
+
+	BaseClass::OnCommand( pCommand );
+}
+
+
+//-----------------------------------------------------------------------------
+// Update column headers
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::UpdateAssetColumnHeader( )
+{
+	char pColumnTitle[512];
+	Q_snprintf( pColumnTitle, sizeof(pColumnTitle), "%s (%d/%d)%s",
+		m_pAssetType, m_nMatchingAssets, m_AssetList.Count(), m_bFinishedAssetListScan ? "" : " ..." );
+	m_pAssetBrowser->SetColumnHeaderText( 1, pColumnTitle );
+}
+
+	
+//-----------------------------------------------------------------------------
+// Request focus of the filter box
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::RequestFilterFocus()
+{
+    if ( m_Filter.Length() )
+	{
+		m_pFilter->SelectAllOnFirstFocus( true );
+	}
+	m_pFilter->RequestFocus();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: refreshes the asset list
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::RefreshAssetList( )
+{
+	BuildAssetNameList();
+
+	// Check the filter matches
+	int nCount = m_AssetList.Count();
+	m_nMatchingAssets = 0;
+	for ( int i = 0; i < nCount; ++i )
+	{
+		// Filter based on active mod
+		bool bIsVisible = IsAssetVisible( i );
+		m_pAssetBrowser->SetItemVisible( m_AssetList[i].m_nItemId, bIsVisible );
+		if ( bIsVisible )
+		{
+			++m_nMatchingAssets;
+		}
+	}
+
+	UpdateAssetColumnHeader();
+	m_pAssetBrowser->SortList();
+
+	if ( ( m_pAssetBrowser->GetSelectedItemsCount() == 0 ) && ( m_pAssetBrowser->GetItemCount() > 0 ) )
+	{
+		// Invoke a callback if the next selection will be a 'default' selection
+		OnNextSelectionIsDefault();
+		int nItemID = m_pAssetBrowser->GetItemIDFromRow( 0 );
+		m_pAssetBrowser->SetSelectedCell( nItemID, 0 );
+	}
+
+	m_pFileTree->RefreshFileList();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: refreshes dialog on file folder changing
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::OnFileSelected()
+{
+	// update list
+	const char *pFolderFilter = "";
+	int iItem = m_pFileTree->GetFirstSelectedItem();
+	if ( iItem >= 0 )
+	{
+		KeyValues *pkv = m_pFileTree->GetItemData( iItem );
+		pFolderFilter = pkv->GetString( "path" );
+
+		// The first keys are always the subdir
+		pFolderFilter += Q_strlen( m_pAssetSubDir );
+		if ( *pFolderFilter )
+		{
+			++pFolderFilter;
+		}
+	}
+
+	if ( Q_stricmp( pFolderFilter, m_FolderFilter.Get() ) )
+	{
+		int nLen = Q_strlen( pFolderFilter );
+		m_FolderFilter = pFolderFilter;
+		if ( nLen > 0 )
+		{
+			m_FolderFilter += '\\';
+		}
+		RefreshAssetList();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: refreshes dialog on text changing
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::OnTextChanged( KeyValues *pKeyValues )
+{
+	vgui::Panel *pSource = (vgui::Panel*)pKeyValues->GetPtr( "panel" );
+	if ( pSource == m_pFilter )
+	{
+		int nLength = m_pFilter->GetTextLength();
+		char *pNewFilter = (char*)_alloca( (nLength+1) * sizeof(char) );
+		if ( nLength > 0 )
+		{
+			m_pFilter->GetText( pNewFilter, nLength+1 );
+		}
+		else
+		{
+			pNewFilter[0] = 0;
+		}
+		if ( Q_stricmp( pNewFilter, m_Filter.Get() ) )
+		{
+			m_Filter.SetLength( nLength );
+			m_Filter = pNewFilter;
+			RefreshAssetList();
+		}
+		return;
+	}
+
+	if ( pSource == m_pModSelector )
+	{
+		KeyValues *pKeyValuesActive = m_pModSelector->GetActiveItemUserData();
+		if ( pKeyValuesActive )
+		{
+			m_nCurrentModFilter = pKeyValuesActive->GetInt( "mod", -1 );
+			RefreshAssetList();
+		}
+		return;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Updates preview when an item is selected
+//-----------------------------------------------------------------------------
+void CBaseAssetPicker::OnItemSelected( KeyValues *kv )
+{
+	Panel *pPanel = (Panel *)kv->GetPtr( "panel", NULL );
+	if ( pPanel == m_pAssetBrowser )
+	{
+		int nCount = GetSelectedAssetCount();
+		Assert( nCount > 0 );
+		const char *pSelectedAsset = GetSelectedAsset( nCount - 1 );
+
+		// Fill in the full path
+		int nModIndex = GetSelectedAssetModIndex();
+		char pBuf[MAX_PATH];
+		Q_snprintf( pBuf, sizeof(pBuf), "%s\\%s\\%s", 
+			s_AssetCache.ModInfo( nModIndex ).m_Path.Get(), m_pAssetSubDir, pSelectedAsset );
+		Q_FixSlashes( pBuf );
+		m_pFullPath->SetText( pBuf );
+
+		surface()->SetCursor( dc_waitarrow );
+		OnSelectedAssetPicked( pSelectedAsset );
+		return;
+	}
+}
+
+void CBaseAssetPicker::OnCheckButtonChecked( KeyValues *kv )
+{
+	vgui::Panel *pSource = (vgui::Panel*)kv->GetPtr( "panel" );
+	if ( pSource == m_pSubDirCheck )
+	{
+		m_bSubDirCheck = m_pSubDirCheck->IsSelected();
+		RefreshAssetList();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Returns the selceted asset count
+//-----------------------------------------------------------------------------
+int CBaseAssetPicker::GetSelectedAssetCount()
+{
+	return m_pAssetBrowser->GetSelectedItemsCount();
+}
+
+	
+//-----------------------------------------------------------------------------
+// Returns the selceted asset name
+//-----------------------------------------------------------------------------
+const char *CBaseAssetPicker::GetSelectedAsset( int nAssetIndex )
+{
+	int nSelectedAssetCount = m_pAssetBrowser->GetSelectedItemsCount();
+	if ( nAssetIndex < 0 )
+	{
+		nAssetIndex = nSelectedAssetCount - 1;
+	}
+	if ( nSelectedAssetCount <= nAssetIndex || nAssetIndex < 0 )
+		return NULL;
+
+	int nIndex = m_pAssetBrowser->GetSelectedItem( nAssetIndex );
+	KeyValues *pItemKeyValues = m_pAssetBrowser->GetItem( nIndex );
+	return pItemKeyValues->GetString( "asset" );
+}
+
+	
+//-----------------------------------------------------------------------------
+// Returns the selceted asset mod index
+//-----------------------------------------------------------------------------
+int CBaseAssetPicker::GetSelectedAssetModIndex( )
+{
+	if ( m_pAssetBrowser->GetSelectedItemsCount() == 0 )
+		return 0;
+
+	int nIndex = m_pAssetBrowser->GetSelectedItem( 0 );
+	KeyValues *pItemKeyValues = m_pAssetBrowser->GetItem( nIndex );
+	return pItemKeyValues->GetInt( "modIndex" );
+}
+
+
+//-----------------------------------------------------------------------------
+//
+// Purpose: Modal picker frame
+//
+//-----------------------------------------------------------------------------
+CBaseAssetPickerFrame::CBaseAssetPickerFrame( vgui::Panel *pParent ) : 
+	BaseClass( pParent, "AssetPickerFrame" )
+{
+	m_pContextKeyValues = NULL;
+	SetDeleteSelfOnClose( true );
+	m_pOpenButton = new Button( this, "OpenButton", "#FileOpenDialog_Open", this, "Open" );
+	m_pCancelButton = new Button( this, "CancelButton", "#FileOpenDialog_Cancel", this, "Cancel" );
+	SetBlockDragChaining( true );
+}
+
+CBaseAssetPickerFrame::~CBaseAssetPickerFrame()
+{
+	CleanUpMessage();
+}
+
+
+//-----------------------------------------------------------------------------
+// Allows the derived class to create the picker
+//-----------------------------------------------------------------------------
+void CBaseAssetPickerFrame::SetAssetPicker( CBaseAssetPicker* pPicker )
+{
+	m_pPicker = pPicker;
+	m_pPicker->AddActionSignalTarget( this );
+}
+
+	
+//-----------------------------------------------------------------------------
+// Deletes the message
+//-----------------------------------------------------------------------------
+void CBaseAssetPickerFrame::CleanUpMessage()
+{
+	if ( m_pContextKeyValues )
+	{
+		m_pContextKeyValues->deleteThis();
+		m_pContextKeyValues = NULL;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Sets the initial selected asset
+//-----------------------------------------------------------------------------
+void CBaseAssetPickerFrame::SetInitialSelection( const char *pAssetName )
+{	
+	m_pPicker->SetInitialSelection( pAssetName );
+}
+	
+
+//-----------------------------------------------------------------------------
+// Set/get the filter
+//-----------------------------------------------------------------------------
+void CBaseAssetPickerFrame::SetFilter( const char *pFilter )
+{
+	m_pPicker->SetFilter( pFilter );
+}
+
+const char *CBaseAssetPickerFrame::GetFilter()
+{
+	return m_pPicker->GetFilter( );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Activate the dialog
+//-----------------------------------------------------------------------------
+void CBaseAssetPickerFrame::DoModal( KeyValues *pKeyValues )
+{
+	BaseClass::DoModal();
+	CleanUpMessage();
+	m_pContextKeyValues = pKeyValues;
+	m_pPicker->Activate();
+}
+
+
+//-----------------------------------------------------------------------------
+// Posts a message (passing the key values)
+//-----------------------------------------------------------------------------
+void CBaseAssetPickerFrame::PostMessageAndClose( KeyValues *pKeyValues )
+{
+	if ( m_pContextKeyValues )
+	{
+		pKeyValues->AddSubKey( m_pContextKeyValues );
+		m_pContextKeyValues = NULL;
+	}
+	CloseModal();
+	PostActionSignal( pKeyValues );
+}
+
+
+//-----------------------------------------------------------------------------
+// On command
+//-----------------------------------------------------------------------------
+void CBaseAssetPickerFrame::OnCommand( const char *pCommand )
+{
+	if ( !Q_stricmp( pCommand, "Open" ) )
+	{
+		KeyValues *pActionKeys = new KeyValues( "AssetSelected" );
+		if ( !m_pPicker->IsMultiselectEnabled() )
+		{
+			const char *pAssetName = m_pPicker->GetSelectedAsset( );
+			pActionKeys->SetString( "asset", pAssetName );
+		}
+		else
+		{
+			char pBuf[512];
+			KeyValues *pAssetKeys = pActionKeys->FindKey( "assets", true );
+			int nCount = m_pPicker->GetSelectedAssetCount();
+			for ( int i = 0; i < nCount; ++i )
+			{
+				Q_snprintf( pBuf, sizeof(pBuf), "asset%d", i );
+				pAssetKeys->SetString( pBuf, m_pPicker->GetSelectedAsset( i ) );
+			}
+		}
+		PostMessageAndClose( pActionKeys );
+		return;
+	}
+
+	if ( !Q_stricmp( pCommand, "Cancel" ) )
+	{
+		CloseModal();
+		return;
+	}
+
+	BaseClass::OnCommand( pCommand );
+}
+
+