//===== Copyright (c) 1996-2005, Valve Corporation, All rights reserved. ======// // // Purpose: Implementation of vgui generic open file dialog // // $NoKeywords: $ //===========================================================================// #define PROTECTED_THINGS_DISABLE #if defined( WIN32 ) #if !defined( _GAMECONSOLE ) #include "winlite.h" #include #endif #elif defined( POSIX ) #include #define _stat stat #define _wcsnicmp wcsncmp #else #error #endif #undef GetCurrentDirectory #include "filesystem.h" #include #include "tier1/utldict.h" #include "tier1/utlstring.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if defined( _X360 ) #include "xbox/xbox_win32stubs.h" #undef GetCurrentDirectory #endif #if defined( _PS3 ) #include "ps3/ps3_core.h" #include "ps3/ps3_win32stubs.h" #undef GetCurrentDirectory #endif #include "tier1/fmtstr.h" // memdbgon must be the last include file in a .cpp file!!! #include using namespace vgui; static int s_nLastSortColumn = 0; static const int MAX_FILTER_LENGTH = 255; static const int MAX_SEARCH_HISTORY = 8; static int ListFileNameSortFunc(ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 ) { NOTE_UNUSED( pPanel ); bool dir1 = item1.kv->GetInt("directory") == 1; bool dir2 = item2.kv->GetInt("directory") == 1; // if they're both not directories of files, return if dir1 is a directory (before files) if (dir1 != dir2) { return dir1 ? -1 : 1; } const char *string1 = item1.kv->GetString("text"); const char *string2 = item2.kv->GetString("text"); // YWB: Mimic windows behavior where filenames starting with numbers are sorted based on numeric part int num1 = Q_atoi( string1 ); int num2 = Q_atoi( string2 ); if ( num1 != 0 && num2 != 0 ) { if ( num1 < num2 ) return -1; else if ( num1 > num2 ) return 1; } // Push numbers before everything else if ( num1 != 0 ) { return -1; } // Push numbers before everything else if ( num2 != 0 ) { return 1; } return Q_stricmp( string1, string2 ); } static int ListBaseStringSortFunc(ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2, char const *fieldName ) { bool dir1 = item1.kv->GetInt("directory") == 1; bool dir2 = item2.kv->GetInt("directory") == 1; // if they're both not directories of files, return if dir1 is a directory (before files) if (dir1 != dir2) { return -1; } const char *string1 = item1.kv->GetString(fieldName); const char *string2 = item2.kv->GetString(fieldName); int cval = Q_stricmp(string1, string2); if ( cval == 0 ) { // Use filename to break ties return ListFileNameSortFunc( pPanel, item1, item2 ); } return cval; } static int ListBaseInteger64SortFunc(ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2, char const *fieldName ) { bool dir1 = item1.kv->GetInt("directory") == 1; bool dir2 = item2.kv->GetInt("directory") == 1; // if they're both not directories of files, return if dir1 is a directory (before files) if ( dir1 != dir2 ) { return dir1 ? -1 : 1; } int64 n1 = (int64)item1.kv->GetUint64( fieldName ); int64 n2 = (int64)item2.kv->GetUint64( fieldName ); if ( n1 == n2 ) { // Use filename to break ties return ListFileNameSortFunc( pPanel, item1, item2 ); } return ( n1 < n2 ) ? -1 : 1; } static int ListFileSizeSortFunc(ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 ) { return ListBaseInteger64SortFunc( pPanel, item1, item2, "filesizeint" ); } static int ListFileModifiedSortFunc(ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 ) { // NOTE: Backward order to get most recent files first return ListBaseInteger64SortFunc( pPanel, item2, item1, "modifiedint" ); } static int ListFileCreatedSortFunc(ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 ) { // NOTE: Backward order to get most recent files first return ListBaseInteger64SortFunc( pPanel, item2, item1, "createdint" ); } static int ListFileAttributesSortFunc(ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 ) { return ListBaseStringSortFunc( pPanel, item1, item2, "attributes" ); } static int ListFileTypeSortFunc(ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 ) { return ListBaseStringSortFunc( pPanel, item1, item2, "type" ); } namespace vgui { class FileNameComboBox : public ComboBox { DECLARE_CLASS_SIMPLE( FileNameComboBox, ComboBox ); public: FileNameComboBox(FileOpenDialog *parent, const char *panelName, int numLines, bool allowEdit) : BaseClass( parent, panelName, numLines, allowEdit ) { } virtual void OnKeyCodeTyped( KeyCode code ) { if ( code == KEY_ENTER && !IsDropdownVisible() ) { // Post to parent CallParentFunction(new KeyValues("KeyCodeTyped", "code", code)); return; } BaseClass::OnKeyCodeTyped( code ); } virtual void OnMenuItemSelected() { BaseClass::OnMenuItemSelected(); PostMessage( GetVParent(), new KeyValues( "OnMatchStringSelected" ) ); } }; } // namespace vgui //----------------------------------------------------------------------------- // Dictionary of start dir contexts //----------------------------------------------------------------------------- static CUtlDict< CUtlString, unsigned short > s_StartDirContexts; struct ColumnInfo_t { char const *columnName; char const *columnText; int startingWidth; int minWidth; int maxWidth; int flags; SortFunc *pfnSort; Label::Alignment alignment; }; static ColumnInfo_t g_ColInfo[] = { { "text", "#FileOpenDialog_Col_Name", 175, 20, 10000, ListPanel::COLUMN_UNHIDABLE, &ListFileNameSortFunc , Label::a_west }, { "filesize", "#FileOpenDialog_Col_Size", 100, 20, 10000, 0, &ListFileSizeSortFunc , Label::a_east }, { "type", "#FileOpenDialog_Col_Type", 150, 20, 10000, 0, &ListFileTypeSortFunc , Label::a_west }, { "modified", "#FileOpenDialog_Col_DateModified", 125, 20, 10000, 0, &ListFileModifiedSortFunc , Label::a_west }, // { "created", "#FileOpenDialog_Col_DateCreated", 125, 20, 10000, ListPanel::COLUMN_HIDDEN, &ListFileCreatedSortFunc , Label::a_west }, { "attributes", "#FileOpenDialog_Col_Attributes", 50, 20, 10000, ListPanel::COLUMN_HIDDEN, &ListFileAttributesSortFunc , Label::a_west }, }; //----------------------------------------------------------------------------- // Purpose: Constructor //----------------------------------------------------------------------------- FileOpenDialog::FileOpenDialog(Panel *parent, const char *title, bool bOpenOnly, KeyValues* pContextKeyValues ) : Frame( parent, "FileOpenDialog" ) { m_DialogType = bOpenOnly ? FOD_OPEN : FOD_SAVE; Init( title, pContextKeyValues ); } FileOpenDialog::FileOpenDialog( Panel *parent, const char *title, FileOpenDialogType_t type, KeyValues *pContextKeyValues ) : Frame( parent, "FileOpenDialog" ) { m_DialogType = type; Init( title, pContextKeyValues ); } void FileOpenDialog::Init( const char *title, KeyValues *pContextKeyValues ) { // By default, delete self on close SetDeleteSelfOnClose( true ); m_bFileSelected = false; SetTitle(title, true); SetMinimizeButtonVisible(false); #ifdef POSIX V_strncpy(m_szLastPath, "/", sizeof( m_szLastPath ) ); #else V_strncpy(m_szLastPath, "c:\\", sizeof( m_szLastPath ) ); #endif m_pContextKeyValues = pContextKeyValues; // Get the list of available drives and put them in a menu here. // Start with the directory we are in. m_pFullPathEdit = new ComboBox(this, "FullPathEdit", 6, false); m_pFullPathEdit->GetTooltip()->SetTooltipFormatToSingleLine(); // list panel m_pFileList = new ListPanel(this, "FileList"); for ( int i = 0; i < ARRAYSIZE( g_ColInfo ); ++i ) { const ColumnInfo_t& info = g_ColInfo[ i ]; m_pFileList->AddColumnHeader( i, info.columnName, info.columnText, info.startingWidth, info.minWidth, info.maxWidth, info.flags ); m_pFileList->SetSortFunc( i, info.pfnSort ); m_pFileList->SetColumnTextAlignment( i, info.alignment ); } m_pFileList->SetSortColumn( s_nLastSortColumn ); m_pFileList->SetMultiselectEnabled( false ); // file name edit box m_pFileNameCombo = new FileNameComboBox(this, "FileNameCombo", 6, true ); m_pFileTypeCombo = new ComboBox( this, "FileTypeCombo", 6, false ); switch ( m_DialogType ) { case FOD_OPEN: m_pOpenButton = new Button( this, "OpenButton", "#FileOpenDialog_Open", this ); break; case FOD_SAVE: m_pOpenButton = new Button( this, "OpenButton", "#FileOpenDialog_Save", this ); break; case FOD_SELECT_DIRECTORY: m_pOpenButton = new Button( this, "OpenButton", "#FileOpenDialog_Select", this ); m_pFileTypeCombo->SetVisible( false ); break; } m_pCancelButton = new Button( this, "CancelButton", "#FileOpenDialog_Cancel", this ); m_pFolderUpButton = new Button( this, "FolderUpButton", "", this ); m_pFolderUpButton->GetTooltip()->SetText( "#FileOpenDialog_ToolTip_Up" ); m_pNewFolderButton = new Button( this, "NewFolderButton", "", this ); m_pNewFolderButton->GetTooltip()->SetText( "#FileOpenDialog_ToolTip_NewFolder" ); m_pOpenInExplorerButton = new Button( this, "OpenInExplorerButton", "", this ); #if defined ( OSX ) m_pOpenInExplorerButton->GetTooltip()->SetText( "#FileOpenDialog_ToolTip_OpenInFinderButton" ); #elif defined ( POSIX ) m_pOpenInExplorerButton->GetTooltip()->SetText( "#FileOpenDialog_ToolTip_OpenInDesktopManagerButton" ); #else // Assume Windows / Explorer m_pOpenInExplorerButton->GetTooltip()->SetText( "#FileOpenDialog_ToolTip_OpenInExplorerButton" ); #endif Label *lookIn = new Label( this, "LookInLabel", "#FileOpenDialog_Look_in" ); Label *fileName = new Label( this, "FileNameLabel", ( m_DialogType != FOD_SELECT_DIRECTORY ) ? "#FileOpenDialog_File_name" : "#FileOpenDialog_Directory_Name" ); // set up the control's initial positions SetSize( 600, 260 ); int nFileEditLeftSide = ( m_DialogType != FOD_SELECT_DIRECTORY ) ? 84 : 100; int nFileNameWidth = ( m_DialogType != FOD_SELECT_DIRECTORY ) ? 72 : 82; m_pFullPathEdit->SetBounds(67, 32, 310, 24); m_pFolderUpButton->SetBounds(362, 32, 24, 24); m_pNewFolderButton->SetBounds(392, 32, 24, 24); m_pOpenInExplorerButton->SetBounds(332, 32, 24, 24); m_pFileList->SetBounds(10, 60, 406, 130); m_pFileNameCombo->SetBounds( nFileEditLeftSide, 194, 238, 24); m_pFileTypeCombo->SetBounds( nFileEditLeftSide, 224, 238, 24); m_pOpenButton->SetBounds(336, 194, 74, 24); m_pCancelButton->SetBounds(336, 224, 74, 24); lookIn->SetBounds(10, 32, 55, 24); fileName->SetBounds(10, 194, nFileNameWidth, 24); // set autolayout parameters m_pFullPathEdit->SetAutoResize( Panel::PIN_TOPLEFT, Panel::AUTORESIZE_RIGHT, 67, 32, -100, 0 ); m_pFileNameCombo->SetAutoResize( Panel::PIN_BOTTOMLEFT, Panel::AUTORESIZE_RIGHT, nFileEditLeftSide, -42, -104, 0 ); m_pFileTypeCombo->SetAutoResize( Panel::PIN_BOTTOMLEFT, Panel::AUTORESIZE_RIGHT, nFileEditLeftSide, -12, -104, 0 ); m_pFileList->SetAutoResize( Panel::PIN_TOPLEFT, Panel::AUTORESIZE_DOWNANDRIGHT, 10, 60, -10, -70 ); m_pFolderUpButton->SetPinCorner( Panel::PIN_TOPRIGHT, -40, 32 ); m_pNewFolderButton->SetPinCorner( Panel::PIN_TOPRIGHT, -10, 32 ); m_pOpenInExplorerButton->SetPinCorner( Panel::PIN_TOPRIGHT, -70, 32 ); m_pOpenButton->SetPinCorner( Panel::PIN_BOTTOMRIGHT, -16, -42 ); m_pCancelButton->SetPinCorner( Panel::PIN_BOTTOMRIGHT, -16, -12 ); lookIn->SetPinCorner( Panel::PIN_TOPLEFT, 10, 32 ); fileName->SetPinCorner( Panel::PIN_BOTTOMLEFT, 10, -42 ); // label settings lookIn->SetContentAlignment(Label::a_west); fileName->SetContentAlignment(Label::a_west); lookIn->SetAssociatedControl(m_pFullPathEdit); fileName->SetAssociatedControl(m_pFileNameCombo); if ( m_DialogType != FOD_SELECT_DIRECTORY ) { Label *fileType = new Label(this, "FileTypeLabel", "#FileOpenDialog_File_type"); fileType->SetBounds(10, 224, 72, 24); fileType->SetPinCorner( Panel::PIN_BOTTOMLEFT, 10, -12 ); fileType->SetContentAlignment(Label::a_west); fileType->SetAssociatedControl( m_pFileTypeCombo ); } // set tab positions GetFocusNavGroup().SetDefaultButton(m_pOpenButton); m_pFileNameCombo->SetTabPosition(1); m_pFileTypeCombo->SetTabPosition(2); m_pOpenButton->SetTabPosition(3); m_pCancelButton->SetTabPosition(4); m_pFullPathEdit->SetTabPosition(5); m_pFileList->SetTabPosition(6); m_pOpenButton->SetCommand( ( m_DialogType != FOD_SELECT_DIRECTORY ) ? new KeyValues( "OnOpen" ) : new KeyValues( "SelectFolder" ) ); m_pCancelButton->SetCommand( "CloseModal" ); m_pFolderUpButton->SetCommand( new KeyValues( "OnFolderUp" ) ); m_pNewFolderButton->SetCommand( new KeyValues( "OnNewFolder" ) ); m_pOpenInExplorerButton->SetCommand( new KeyValues( "OpenInExplorer" ) ); SetSize( 600, 384 ); m_nStartDirContext = s_StartDirContexts.InvalidIndex(); // Set our starting path to the current directory char pLocalPath[255]; g_pFullFileSystem->GetCurrentDirectory( pLocalPath , 255 ); SetStartDirectory( pLocalPath ); // Because these call through virtual functions, we can't issue them in the constructor, so we post a message to ourselves instead!! PostMessage( GetVPanel(), new KeyValues( "PopulateFileList" ) ); PostMessage( GetVPanel(), new KeyValues( "PopulateDriveList" ) ); } //----------------------------------------------------------------------------- // Purpose: Destructor //----------------------------------------------------------------------------- FileOpenDialog::~FileOpenDialog() { s_nLastSortColumn = m_pFileList->GetSortColumn(); if ( m_pContextKeyValues ) { m_pContextKeyValues->deleteThis(); m_pContextKeyValues = NULL; } } //----------------------------------------------------------------------------- // Purpose: Apply scheme settings //----------------------------------------------------------------------------- void FileOpenDialog::ApplySchemeSettings(IScheme *pScheme) { BaseClass::ApplySchemeSettings(pScheme); m_pFolderUpButton->SetImage( scheme()->GetImage("resource/icon_folderup", false), 0 ); m_pFolderUpButton->SetContentAlignment( Label::a_center ); m_pNewFolderButton->SetImage( scheme()->GetImage("resource/icon_newfolder", false), 0 ); m_pNewFolderButton->SetContentAlignment( Label::a_center ); m_pOpenInExplorerButton->SetImage( scheme()->GetImage("resource/icon_explore", false), 0 ); m_pOpenInExplorerButton->SetContentAlignment( Label::a_center ); ImageList *imageList = new ImageList(false); imageList->AddImage(scheme()->GetImage("resource/icon_file", false)); imageList->AddImage(scheme()->GetImage("resource/icon_folder", false)); imageList->AddImage(scheme()->GetImage("resource/icon_folder_selected", false)); m_pFileList->SetImageList(imageList, true); } //----------------------------------------------------------------------------- // Prevent default button ('select') from getting triggered // when selecting directories. Instead, open the directory //----------------------------------------------------------------------------- void FileOpenDialog::OnKeyCodeTyped(KeyCode code) { if ( m_DialogType == FOD_SELECT_DIRECTORY && code == KEY_ENTER ) { OnOpen(); } else { BaseClass::OnKeyCodeTyped( code ); } } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void FileOpenDialog::PopulateDriveList() { char fullpath[MAX_PATH * 4]; char subDirPath[MAX_PATH * 4]; GetCurrentDirectory(fullpath, sizeof(fullpath) - MAX_PATH); Q_strncpy(subDirPath, fullpath, sizeof( subDirPath ) ); m_pFullPathEdit->DeleteAllItems(); // populate the drive list char buf[512]; int len = system()->GetAvailableDrives(buf, 512); char *pBuf = buf; for (int i=0; i < len / 4; i++) { m_pFullPathEdit->AddItem(pBuf, NULL); // is this our drive - add all subdirectories if (!_strnicmp(pBuf, fullpath, 2)) { int indent = 0; char *pData = fullpath; while (*pData) { if (*pData == CORRECT_PATH_SEPARATOR ) { if (indent > 0) { memset(subDirPath, ' ', indent); memcpy(subDirPath+indent, fullpath, pData-fullpath); subDirPath[indent+pData-fullpath] = 0; m_pFullPathEdit->AddItem(subDirPath, NULL); } indent += 2; } pData++; } } pBuf += 4; } } //----------------------------------------------------------------------------- // Purpose: Delete self on close //----------------------------------------------------------------------------- void FileOpenDialog::OnClose() { s_nLastSortColumn = m_pFileList->GetSortColumn(); if ( !m_bFileSelected ) { KeyValues *pKeyValues = new KeyValues( "FileSelectionCancelled" ); PostActionSignal( pKeyValues ); m_bFileSelected = true; } m_pFileNameCombo->SetText(""); m_pFileNameCombo->HideMenu(); if ( vgui::input()->GetAppModalSurface() == GetVPanel() ) { input()->SetAppModalSurface(NULL); } BaseClass::OnClose(); } void FileOpenDialog::OnFolderUp() { MoveUpFolder(); OnOpen(); } void FileOpenDialog::OnInputCompleted( KeyValues *data ) { if ( m_hInputDialog.Get() ) { delete m_hInputDialog.Get(); } input()->SetAppModalSurface( m_SaveModal ); m_SaveModal = 0; NewFolder( data->GetString( "text" ) ); OnOpen(); } void FileOpenDialog::OnInputCanceled() { input()->SetAppModalSurface( m_SaveModal ); m_SaveModal = 0; } void FileOpenDialog::OnNewFolder() { if ( m_hInputDialog.Get() ) delete m_hInputDialog.Get(); m_hInputDialog = new InputDialog( this, "#FileOpenDialog_NewFolder_InputTitle", "#FileOpenDialog_NewFolderPrompt", "#FileOpenDialog_NewFolder_DefaultName" ); if ( m_hInputDialog.Get() ) { m_SaveModal = input()->GetAppModalSurface(); KeyValues *pContextKeyValues = new KeyValues( "NewFolder" ); m_hInputDialog->SetSmallCaption( true ); m_hInputDialog->SetMultiline( false ); m_hInputDialog->DoModal( pContextKeyValues ); } } //----------------------------------------------------------------------------- // Opens the current file/folder in explorer //----------------------------------------------------------------------------- void FileOpenDialog::OnOpenInExplorer() { char pCurrentDirectory[MAX_PATH]; GetCurrentDirectory( pCurrentDirectory, sizeof(pCurrentDirectory) ); #if defined( WIN32 ) #if !defined( _GAMECONSOLE ) ShellExecute( NULL, NULL, pCurrentDirectory, NULL, NULL, SW_SHOWNORMAL ); #endif #elif defined( OSX ) char szCmd[ MAX_PATH ]; Q_snprintf( szCmd, sizeof(szCmd), "/usr/bin/open \"%s\"", pCurrentDirectory ); ::system( szCmd ); #elif defined( LINUX ) DevMsg( "FileOpenDialog::OnOpenInExplorer unimplemented under LINUX\n" ); #endif } void FileOpenDialog::AddSearchHistoryString( char const *str ) { // See if it's already in list for ( int i = 0; i < m_SearchHistory.Count(); ++i ) { if ( !Q_stricmp( str, m_SearchHistory[ i ].String() ) ) return; } while ( m_SearchHistory.Count() > MAX_SEARCH_HISTORY ) { m_SearchHistory.Remove( m_SearchHistory.Count() - 1 ); } CUtlString string; string = str; m_SearchHistory.AddToTail( string ); PopulateFileNameSearchHistory(); } //----------------------------------------------------------------------------- // Purpose: Handle for button commands //----------------------------------------------------------------------------- void FileOpenDialog::OnCommand(const char *command) { if (!stricmp(command, "Cancel")) { Close(); } else { BaseClass::OnCommand(command); } } //----------------------------------------------------------------------------- // Sets the start directory context (and resets the start directory in the process) //----------------------------------------------------------------------------- void FileOpenDialog::SetStartDirectoryContext( const char *pStartDirContext, const char *pDefaultDir ) { bool bUseCurrentDirectory = true; if ( pStartDirContext ) { m_nStartDirContext = s_StartDirContexts.Find( pStartDirContext ); if ( m_nStartDirContext == s_StartDirContexts.InvalidIndex() ) { m_nStartDirContext = s_StartDirContexts.Insert( pStartDirContext, pDefaultDir ); bUseCurrentDirectory = ( pDefaultDir == NULL ); } else { bUseCurrentDirectory = false; } } else { m_nStartDirContext = s_StartDirContexts.InvalidIndex(); } if ( !bUseCurrentDirectory ) { SetStartDirectory( s_StartDirContexts[m_nStartDirContext].Get() ); } else { // Set our starting path to the current directory char pLocalPath[255]; g_pFullFileSystem->GetCurrentDirectory( pLocalPath, 255 ); SetStartDirectory( pLocalPath ); } } //----------------------------------------------------------------------------- // Purpose: Set the starting directory of the file search. //----------------------------------------------------------------------------- void FileOpenDialog::SetStartDirectory( const char *dir ) { m_pFullPathEdit->SetText(dir); // ensure it's validity ValidatePath(); // Store this in the start directory list if ( m_nStartDirContext != s_StartDirContexts.InvalidIndex() ) { char pDirBuf[MAX_PATH]; GetCurrentDirectory( pDirBuf, sizeof(pDirBuf) ); s_StartDirContexts[ m_nStartDirContext ] = pDirBuf; } PopulateDriveList(); } //----------------------------------------------------------------------------- // Purpose: Add filters for the drop down combo box //----------------------------------------------------------------------------- void FileOpenDialog::AddFilter( const char *filter, const char *filterName, bool bActive, const char *pFilterInfo ) { KeyValues *kv = new KeyValues("item"); kv->SetString( "filter", filter ); kv->SetString( "filterinfo", pFilterInfo ); int itemID = m_pFileTypeCombo->AddItem(filterName, kv); if ( bActive ) { m_pFileTypeCombo->ActivateItem(itemID); } } //----------------------------------------------------------------------------- // Purpose: Activate the dialog //----------------------------------------------------------------------------- void FileOpenDialog::DoModal( bool bUnused ) { m_bFileSelected = false; m_pFileNameCombo->RequestFocus(); BaseClass::DoModal(); } //----------------------------------------------------------------------------- // Purpose: Gets the directory this is currently in //----------------------------------------------------------------------------- void FileOpenDialog::GetCurrentDirectory(char *buf, int bufSize) { // get the text from the text entry m_pFullPathEdit->GetText(buf, bufSize); } //----------------------------------------------------------------------------- // Purpose: Get the last selected file name //----------------------------------------------------------------------------- void FileOpenDialog::GetSelectedFileName(char *buf, int bufSize) { m_pFileNameCombo->GetText(buf, bufSize); } //----------------------------------------------------------------------------- // Creates a new folder //----------------------------------------------------------------------------- void FileOpenDialog::NewFolder( char const *folderName ) { char pCurrentDirectory[MAX_PATH]; GetCurrentDirectory( pCurrentDirectory, sizeof(pCurrentDirectory) ); char pFullPath[MAX_PATH]; char pNewFolderName[MAX_PATH]; Q_strncpy( pNewFolderName, folderName, sizeof(pNewFolderName) ); int i = 2; do { Q_MakeAbsolutePath( pFullPath, sizeof(pFullPath), pNewFolderName, pCurrentDirectory ); if ( !g_pFullFileSystem->FileExists( pFullPath, NULL ) && !g_pFullFileSystem->IsDirectory( pFullPath, NULL ) ) { g_pFullFileSystem->CreateDirHierarchy( pFullPath, NULL ); m_pFileNameCombo->SetText( pNewFolderName ); return; } Q_snprintf( pNewFolderName, sizeof(pNewFolderName), "%s%d", folderName, i ); ++i; } while ( i <= 999 ); } //----------------------------------------------------------------------------- // Purpose: Move the directory structure up //----------------------------------------------------------------------------- void FileOpenDialog::MoveUpFolder() { char fullpath[MAX_PATH * 4]; GetCurrentDirectory(fullpath, sizeof(fullpath) - MAX_PATH); // strip it back char *pos = strrchr(fullpath, CORRECT_PATH_SEPARATOR ); if (pos) { *pos = 0; if (!pos[1]) { pos = strrchr(fullpath, CORRECT_PATH_SEPARATOR ); if (pos) { *pos = 0; } } } // append a trailing slash Q_strncat(fullpath, CORRECT_PATH_SEPARATOR_S, sizeof( fullpath ), COPY_ALL_CHARACTERS ); SetStartDirectory(fullpath); PopulateFileList(); InvalidateLayout(); Repaint(); } //----------------------------------------------------------------------------- // Purpose: Validate that the current path is valid //----------------------------------------------------------------------------- void FileOpenDialog::ValidatePath() { char fullpath[MAX_PATH * 4]; GetCurrentDirectory(fullpath, sizeof(fullpath) - MAX_PATH); Q_RemoveDotSlashes( fullpath ); // when statting a directory on Windows, you want to include // the terminal slash exactly when you are statting a root // directory. PKMN. #ifdef _WIN32 if ( Q_strlen( fullpath ) != 3 ) { Q_StripTrailingSlash( fullpath ); } #endif struct _stat buf; if ( ( 0 == _stat( fullpath, &buf ) ) && ( 0 != ( buf.st_mode & S_IFDIR ) ) ) { Q_AppendSlash( fullpath, sizeof( fullpath ) ); Q_strncpy(m_szLastPath, fullpath, sizeof(m_szLastPath)); } else { // failed to load file, use the previously successful path } m_pFullPathEdit->SetText(m_szLastPath); m_pFullPathEdit->GetTooltip()->SetText(m_szLastPath); } static void InitFileData( bool bDirectory, char const *pszFileName, const char *pchDirectoryName, FileData_t &data ) { data.m_FileName = V_UnqualifiedFileName( pszFileName ); data.m_FullPath = CFmtStr( "%s%s", pchDirectoryName, pszFileName ); Q_FixSlashes( data.m_FullPath.Get() ); if ( !bDirectory ) { g_pFullFileSystem->GetFileTypeForFullPath( data.m_FullPath, data.m_FileType, sizeof( data.m_FileType ) ); } data.m_bDirectory = bDirectory; data.m_nFileSize = g_pFullFileSystem->Size( data.m_FullPath.Get() ); if ( !g_pFullFileSystem->IsFileWritable( data.m_FullPath.Get() ) ) data.m_FileAttributes = "R"; long fileModified = g_pFullFileSystem->GetFileTime( data.m_FullPath.Get() ); char pszFileModified[64]; g_pFullFileSystem->FileTimeToString( pszFileModified, sizeof( pszFileModified ), fileModified ); data.m_LastWriteTime = pszFileModified; data.m_nLastWriteTime = fileModified; } void FileData_t::PrepareKV( KeyValues *kv ) { // add the file to the list kv->SetString("text", m_FileName ); kv->SetInt("directory", m_bDirectory ? 1 : 0 ); kv->SetInt("image", m_bDirectory ? 2 : 1 ); kv->SetInt("imageSelected", m_bDirectory ? 3 : 1 ); kv->SetPtr( "iconImage", NULL ); if ( !m_bDirectory ) { IImage *image = surface()->GetIconImageForFullPath( m_FullPath.String() ); if ( image ) { kv->SetPtr( "iconImage", (void *)image ); } kv->SetUint64( "filesizeint", (uint64)m_nFileSize ); kv->SetString( "filesize", Q_pretifymem( (float)m_nFileSize, 0, true ) ); kv->SetWString( "type", m_FileType ); } else { kv->SetUint64( "filesizeint", (uint64)0 ); kv->SetString( "filesize", "" ); kv->SetString( "type", "#FileOpenDialog_FileType_Folder" ); } kv->SetString( "attributes", m_FileAttributes ); kv->SetString( "modified", m_LastWriteTime ); kv->SetString( "created", m_CreationTime ); kv->SetUint64( "modifiedint", m_nLastWriteTime ); kv->SetUint64( "createdint", m_nCreationTime ); } void FileOpenDialog::BuildFileList() { m_Files.RemoveAll(); m_Filtered.RemoveAll(); #ifndef _GAMECONSOLE // get the current directory char currentDir[MAX_PATH * 4]; char dir[MAX_PATH * 4]; char filterList[MAX_FILTER_LENGTH+1]; GetCurrentDirectory(currentDir, sizeof(currentDir)); FileFindHandle_t findHandle; KeyValues *combokv = m_pFileTypeCombo->GetActiveItemUserData(); if (combokv) { Q_strncpy(filterList, combokv->GetString("filter", "*"), MAX_FILTER_LENGTH); } else { // add wildcard for search Q_strncpy(filterList, "*\0", MAX_FILTER_LENGTH); } char *filterPtr = filterList; //KeyValues *kv = new KeyValues("item"); if ( m_DialogType != FOD_SELECT_DIRECTORY ) { while ((filterPtr != NULL) && (*filterPtr != 0)) { // parse the next filter in the list. char curFilter[MAX_FILTER_LENGTH]; curFilter[0] = 0; int i = 0; while ((filterPtr != NULL) && ((*filterPtr == ',') || (*filterPtr == ';') || (*filterPtr <= ' '))) { ++filterPtr; } while ((filterPtr != NULL) && (*filterPtr != ',') && (*filterPtr != ';') && (*filterPtr > ' ')) { curFilter[i++] = *(filterPtr++); } curFilter[i] = 0; if (curFilter[0] == 0) { break; } Q_snprintf( dir, MAX_PATH*4, "%s%s", currentDir, curFilter ); // Open the directory and walk it, loading files const char *pszFileName = g_pFullFileSystem->FindFirst( dir, &findHandle ); while ( pszFileName ) { if ( !g_pFullFileSystem->FindIsDirectory( findHandle ) ) { FileData_t &fd = m_Files[ m_Files.AddToTail() ]; InitFileData( false, pszFileName, currentDir, fd ); } pszFileName = g_pFullFileSystem->FindNext( findHandle ); } g_pFullFileSystem->FindClose( findHandle ); } } // find all the directories GetCurrentDirectory(currentDir, sizeof(currentDir)); Q_snprintf( dir, MAX_PATH*4, "%s*", currentDir ); const char *pszFileName = g_pFullFileSystem->FindFirst( dir, &findHandle ); while ( pszFileName ) { if ( pszFileName[0] != '.' && g_pFullFileSystem->FindIsDirectory( findHandle ) ) { FileData_t &fd = m_Files[ m_Files.AddToTail() ]; InitFileData( true, pszFileName, currentDir, fd ); } pszFileName = g_pFullFileSystem->FindNext( findHandle ); } g_pFullFileSystem->FindClose( findHandle ); #endif } // Static method to do wildcard matching for *, ? and . characters bool FileOpenDialog::FileNameWildCardMatch( char const *string, char const *pattern ) { for (;; ++string) { char stringc=toupper(*string); char patternc=toupper(*pattern++); switch (patternc) { case 0: return(stringc==0); case '?': if (stringc == 0) return(false); break; case '*': if (*pattern==0) return(true); if (*pattern=='.') { if (pattern[1]=='*' && pattern[2]==0) return(true); const char *dot=strchr(string,'.'); if (pattern[1]==0) return (dot==NULL || dot[1]==0); if (dot!=NULL) { string=dot; if (strpbrk(pattern,"*?")==NULL && strchr(string+1,'.')==NULL) return(Q_stricmp(pattern+1,string+1)==0); } } while (*string) if (FileNameWildCardMatch(string++, pattern)) return(true); return(false); default: if (patternc != stringc) { if (patternc=='.' && stringc==0) return(FileNameWildCardMatch(string, pattern )); else return(false); } break; } } } bool FileOpenDialog::PassesFilter( FileData_t *fd ) { // Do the substring filtering if ( fd->m_bDirectory ) return true; // Never filter Save... dialogs if ( m_DialogType == FOD_SAVE ) return true; if ( m_CurrentSubstringFilter.Length() <= 0 ) return true; if ( Q_stristr( fd->m_FileName, m_CurrentSubstringFilter.String() ) ) return true; if ( FileNameWildCardMatch( fd->m_FileName, m_CurrentSubstringFilter.String() ) ) return true; return false; } void FileOpenDialog::FilterFileList() { m_Filtered.RemoveAll(); for ( int i = 0; i < m_Files.Count(); ++i ) { // Apply filter FileData_t *pFD = &m_Files[ i ]; if ( PassesFilter( pFD ) ) { m_Filtered.AddToTail( &m_Files[ i ] ); } } // clear the current list m_pFileList->DeleteAllItems(); KeyValues *kv = new KeyValues("item"); for ( int i = 0; i < m_Filtered.Count(); ++i ) { FileData_t *fd = m_Filtered[ i ]; fd->PrepareKV( kv ); m_pFileList->AddItem(kv, 0, false, false); } kv->deleteThis(); m_pFileList->SortList(); } int FileOpenDialog::CountSubstringMatches() { int nMatches = 0; for ( int i = 0; i < m_Files.Count(); ++i ) { // Apply filter FileData_t *pFD = &m_Files[ i ]; if ( PassesFilter( pFD ) ) { if ( !pFD->m_bDirectory ) { ++nMatches; } } } return nMatches; } //----------------------------------------------------------------------------- // Purpose: Fill the filelist with the names of all the files in the current directory //----------------------------------------------------------------------------- void FileOpenDialog::PopulateFileList() { BuildFileList(); FilterFileList(); } //----------------------------------------------------------------------------- // Does the specified extension match something in the filter list? //----------------------------------------------------------------------------- bool FileOpenDialog::ExtensionMatchesFilter( const char *pExt ) { KeyValues *combokv = m_pFileTypeCombo->GetActiveItemUserData(); if ( !combokv ) return true; char filterList[MAX_FILTER_LENGTH+1]; Q_strncpy( filterList, combokv->GetString("filter", "*"), MAX_FILTER_LENGTH ); char *filterPtr = filterList; while ((filterPtr != NULL) && (*filterPtr != 0)) { // parse the next filter in the list. char curFilter[MAX_FILTER_LENGTH]; curFilter[0] = 0; int i = 0; while ((filterPtr != NULL) && ((*filterPtr == ',') || (*filterPtr == ';') || (*filterPtr <= ' '))) { ++filterPtr; } while ((filterPtr != NULL) && (*filterPtr != ',') && (*filterPtr != ';') && (*filterPtr > ' ')) { curFilter[i++] = *(filterPtr++); } curFilter[i] = 0; if (curFilter[0] == 0) break; if ( !Q_stricmp( curFilter, "*" ) || !Q_stricmp( curFilter, "*.*" ) ) return true; // FIXME: This isn't exactly right, but tough cookies; // it assumes the first two characters of the filter are *. Assert( curFilter[0] == '*' && curFilter[1] == '.' ); if ( !Q_stricmp( &curFilter[2], pExt ) ) return true; } return false; } //----------------------------------------------------------------------------- // Choose the first non *.* filter in the filter list //----------------------------------------------------------------------------- void FileOpenDialog::ChooseExtension( char *pExt, int nBufLen ) { pExt[0] = 0; KeyValues *combokv = m_pFileTypeCombo->GetActiveItemUserData(); if ( !combokv ) return; char filterList[MAX_FILTER_LENGTH+1]; Q_strncpy( filterList, combokv->GetString("filter", "*"), MAX_FILTER_LENGTH ); char *filterPtr = filterList; while ((filterPtr != NULL) && (*filterPtr != 0)) { // parse the next filter in the list. char curFilter[MAX_FILTER_LENGTH]; curFilter[0] = 0; int i = 0; while ((filterPtr != NULL) && ((*filterPtr == ',') || (*filterPtr == ';') || (*filterPtr <= ' '))) { ++filterPtr; } while ((filterPtr != NULL) && (*filterPtr != ',') && (*filterPtr != ';') && (*filterPtr > ' ')) { curFilter[i++] = *(filterPtr++); } curFilter[i] = 0; if (curFilter[0] == 0) break; if ( !Q_stricmp( curFilter, "*" ) || !Q_stricmp( curFilter, "*.*" ) ) continue; // FIXME: This isn't exactly right, but tough cookies; // it assumes the first two characters of the filter are *. Assert( curFilter[0] == '*' && curFilter[1] == '.' ); Q_strncpy( pExt, &curFilter[1], nBufLen ); break; } } //----------------------------------------------------------------------------- // Saves the file to the start dir context //----------------------------------------------------------------------------- void FileOpenDialog::SaveFileToStartDirContext( const char *pFullPath ) { if ( m_nStartDirContext == s_StartDirContexts.InvalidIndex() ) return; char pPath[MAX_PATH]; pPath[0] = 0; Q_ExtractFilePath( pFullPath, pPath, sizeof(pPath) ); s_StartDirContexts[ m_nStartDirContext ] = pPath; } //----------------------------------------------------------------------------- // Posts a file selected message //----------------------------------------------------------------------------- void FileOpenDialog::PostFileSelectedMessage( const char *pFileName ) { m_bFileSelected = true; // open the file! KeyValues *pKeyValues = new KeyValues( "FileSelected", "fullpath", pFileName ); KeyValues *pFilterKeys = m_pFileTypeCombo->GetActiveItemUserData(); const char *pFilterInfo = pFilterKeys ? pFilterKeys->GetString( "filterinfo", NULL ) : NULL; if ( pFilterInfo ) { pKeyValues->SetString( "filterinfo", pFilterInfo ); } if ( m_pContextKeyValues ) { pKeyValues->AddSubKey( m_pContextKeyValues ); m_pContextKeyValues = NULL; } PostActionSignal( pKeyValues ); CloseModal(); } //----------------------------------------------------------------------------- // Selects the current folder //----------------------------------------------------------------------------- void FileOpenDialog::OnSelectFolder() { ValidatePath(); // construct a file path char pFileName[MAX_PATH]; GetSelectedFileName( pFileName, sizeof( pFileName ) ); Q_StripTrailingSlash( pFileName ); if ( !stricmp(pFileName, "..") ) { MoveUpFolder(); // clear the name text m_pFileNameCombo->SetText(""); return; } if ( !stricmp(pFileName, ".") ) { // clear the name text m_pFileNameCombo->SetText(""); return; } // Compute the full path char pFullPath[MAX_PATH * 4]; if ( !Q_IsAbsolutePath( pFileName ) ) { GetCurrentDirectory(pFullPath, sizeof(pFullPath) - MAX_PATH); strcat( pFullPath, pFileName ); if ( !pFileName[0] ) { Q_StripTrailingSlash( pFullPath ); } } else { Q_strncpy( pFullPath, pFileName, sizeof(pFullPath) ); } if ( g_pFullFileSystem->FileExists( pFullPath ) ) { // open the file! SaveFileToStartDirContext( pFullPath ); PostFileSelectedMessage( pFullPath ); return; } PopulateDriveList(); PopulateFileList(); InvalidateLayout(); } //----------------------------------------------------------------------------- // Purpose: Handle the open button being pressed // checks on what has changed and acts accordingly //----------------------------------------------------------------------------- void FileOpenDialog::OnOpen() { ValidatePath(); // construct a file path char pFileName[MAX_PATH]; GetSelectedFileName( pFileName, sizeof( pFileName ) ); int nLen = Q_strlen( pFileName ); bool bSpecifiedDirectory = ( pFileName[nLen-1] == '/' || pFileName[nLen-1] == '\\' ); Q_StripTrailingSlash( pFileName ); if ( !stricmp(pFileName, "..") ) { MoveUpFolder(); // clear the name text m_pFileNameCombo->SetText(""); return; } if ( !stricmp(pFileName, ".") ) { // clear the name text m_pFileNameCombo->SetText(""); return; } // Compute the full path char pFullPath[MAX_PATH * 4]; if ( !Q_IsAbsolutePath( pFileName ) ) { GetCurrentDirectory(pFullPath, sizeof(pFullPath) - MAX_PATH); strcat(pFullPath, pFileName); if ( !pFileName[0] ) { Q_StripTrailingSlash( pFullPath ); } } else { Q_strncpy( pFullPath, pFileName, sizeof(pFullPath) ); } // If the name specified is a directory, then change directory if ( g_pFullFileSystem->IsDirectory( pFullPath, NULL ) ) { // it's a directory; change to the specified directory if ( !bSpecifiedDirectory ) { strcat( pFullPath , CORRECT_PATH_SEPARATOR_S ); } SetStartDirectory( pFullPath ); // clear the name text m_pFileNameCombo->SetText(""); m_pFileNameCombo->HideMenu(); m_CurrentSubstringFilter = ""; PopulateDriveList(); PopulateFileList(); InvalidateLayout(); return; } else if ( bSpecifiedDirectory ) { PopulateDriveList(); PopulateFileList(); InvalidateLayout(); return; } m_CurrentSubstringFilter = pFileName; AddSearchHistoryString( pFileName ); if ( m_DialogType != FOD_SAVE ) { if ( m_CurrentSubstringFilter.Length() > 0 ) { // It's ambiguous int nMatches = CountSubstringMatches(); if ( nMatches >= 2 ) { // Apply filter instead FilterFileList(); return; } } } // Append suffix of the first filter that isn't *.* char extension[512]; Q_ExtractFileExtension( pFullPath, extension, sizeof(extension) ); if ( !ExtensionMatchesFilter( extension ) ) { ChooseExtension( extension, sizeof(extension) ); Q_SetExtension( pFullPath, extension, sizeof(pFullPath) ); } if ( g_pFullFileSystem->FileExists( pFullPath ) ) { // open the file! SaveFileToStartDirContext( pFullPath ); PostFileSelectedMessage( pFullPath ); return; } // file not found if ( ( m_DialogType == FOD_SAVE ) && pFileName[0] ) { // open the file! SaveFileToStartDirContext( pFullPath ); PostFileSelectedMessage( pFullPath ); return; } PopulateDriveList(); PopulateFileList(); InvalidateLayout(); } //----------------------------------------------------------------------------- // Purpose: using the file edit box as a prefix, create a menu of all possible files //----------------------------------------------------------------------------- void FileOpenDialog::PopulateFileNameSearchHistory() { m_pFileNameCombo->RemoveAll(); for ( int i = 0; i < m_SearchHistory.Count(); ++i ) { m_pFileNameCombo->AddItem( m_SearchHistory[ i ].String(), 0 ); } } //----------------------------------------------------------------------------- // Purpose: Handle an item in the list being selected //----------------------------------------------------------------------------- void FileOpenDialog::OnItemSelected() { // make sure only one item is selected if (m_pFileList->GetSelectedItemsCount() != 1) { m_pFileNameCombo->SetText(""); } else { // put the file name into the text edit box KeyValues *data = m_pFileList->GetItem(m_pFileList->GetSelectedItem(0)); m_pFileNameCombo->SetText(data->GetString("text")); } InvalidateLayout(); } void FileOpenDialog::OnMatchStringSelected() { char pFileName[MAX_PATH]; GetSelectedFileName( pFileName, sizeof( pFileName ) ); m_pFileNameCombo->GetText( pFileName, sizeof( pFileName ) ); m_CurrentSubstringFilter = pFileName; // Redo filter FilterFileList(); } //----------------------------------------------------------------------------- // Purpose: Handle an item in the Drive combo box being selected //----------------------------------------------------------------------------- void FileOpenDialog::OnTextChanged(KeyValues *kv) { Panel *pPanel = (Panel *) kv->GetPtr("panel", NULL); // first check which control had its text changed! if (pPanel == m_pFullPathEdit) { m_pFileNameCombo->HideMenu(); m_pFileNameCombo->SetText(""); OnOpen(); } else if (pPanel == m_pFileNameCombo) { // Don't react to text being typed } else if (pPanel == m_pFileTypeCombo) { m_pFileNameCombo->HideMenu(); PopulateFileList(); } }