d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
383 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 8c0f758a57
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '8c0f758a57'
${ noResults }
source-engine/vgui2/vgui_controls/FileOpenDialog.cpp

1703 lines
47 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Implementation of vgui generic open file dialog
//
// $NoKeywords: $
//===========================================================================//
#define PROTECTED_THINGS_DISABLE
#if !defined( _X360 ) && defined( WIN32 )
#include "winlite.h"
#include <shellapi.h>
#elif defined( POSIX )
#include <stdlib.h>
#define _stat stat
#define _wcsnicmp wcsncmp
#elif defined( _X360 )
#else
#error
#endif
#undef GetCurrentDirectory
#include "filesystem.h"
#include <sys/stat.h>
#include "tier1/utldict.h"
#include "tier1/utlstring.h"
#include <vgui/IScheme.h>
#include <vgui/ISurface.h>
#include <vgui/ISystem.h>
#include <KeyValues.h>
#include <vgui/IVGui.h>
#include <vgui/ILocalize.h>
#include <vgui/IInput.h>
#include <vgui_controls/FileOpenDialog.h>
#include <vgui_controls/Button.h>
#include <vgui_controls/ComboBox.h>
#include <vgui_controls/ImagePanel.h>
#include <vgui_controls/InputDialog.h>
#include <vgui_controls/Label.h>
#include <vgui_controls/ListPanel.h>
#include <vgui_controls/TextEntry.h>
#include <vgui_controls/ImageList.h>
#include <vgui_controls/MenuItem.h>
#include <vgui_controls/Tooltip.h>
#if defined( _X360 )
#include "xbox/xbox_win32stubs.h"
#undef GetCurrentDirectory
#endif
#include <time.h>
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
using namespace vgui;
static int s_nLastSortColumn = 0;
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 ListBaseIntegerSortFunc(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;
}
int i1 = item1.kv->GetInt(fieldName);
int i2 = item2.kv->GetInt(fieldName);
if ( i1 == i2 )
{
// Use filename to break ties
return ListFileNameSortFunc( pPanel, item1, item2 );
}
return ( i1 < i2 ) ? -1 : 1;
}
static int ListBaseInteger64SortFunc(ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2, char const *lowfield, char const *highfield )
{
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;
}
uint32 l1 = item1.kv->GetInt(lowfield);
uint32 h1 = item1.kv->GetInt(highfield);
uint32 l2 = item2.kv->GetInt(lowfield);
uint32 h2 = item2.kv->GetInt(highfield);
uint64 i1 = (uint64)( (uint64)l1 | ( (uint64)h1 << 32 ) );
uint64 i2 = (uint64)( (uint64)l2 | ( (uint64)h2 << 32 ) );
if ( i1 == i2 )
{
// Use filename to break ties
return ListFileNameSortFunc( pPanel, item1, item2 );
}
return ( i1 < i2 ) ? -1 : 1;
}
static int ListFileSizeSortFunc(ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 )
{
return ListBaseIntegerSortFunc( 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_low", "modifiedint_high" );
}
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_low", "createdint_high" );
}
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 FileCompletionMenu : public Menu
{
public:
FileCompletionMenu(Panel *parent, const char *panelName) : Menu(parent, panelName)
{
}
// override it so it doesn't request focus
virtual void SetVisible(bool state)
{
Panel::SetVisible(state);
}
};
//-----------------------------------------------------------------------------
// File completion edit text entry
//-----------------------------------------------------------------------------
class FileCompletionEdit : public TextEntry
{
DECLARE_CLASS_SIMPLE( FileCompletionEdit, TextEntry );
public:
FileCompletionEdit(Panel *parent);
~FileCompletionEdit();
int AddItem(const char *itemText, KeyValues *userData);
int AddItem(const wchar_t *itemText, KeyValues *userData);
void DeleteAllItems();
int GetItemCount();
int GetItemIDFromRow(int row);
int GetRowFromItemID(int itemID);
virtual void PerformLayout();
void OnSetText(const wchar_t *newtext);
virtual void OnKillFocus();
void HideMenu(void);
void ShowMenu(void);
virtual void OnKeyCodeTyped(KeyCode code);
MESSAGE_FUNC_INT( OnMenuItemHighlight, "MenuItemHighlight", itemID );
private:
FileCompletionMenu *m_pDropDown;
};
FileCompletionEdit::FileCompletionEdit(Panel *parent) : TextEntry(parent, NULL)
{
m_pDropDown = new FileCompletionMenu(this, NULL);
m_pDropDown->AddActionSignalTarget(this);
}
FileCompletionEdit::~FileCompletionEdit()
{
delete m_pDropDown;
}
int FileCompletionEdit::AddItem(const char *itemText, KeyValues *userData)
{
// when the menu item is selected it will send the custom message "SetText"
return m_pDropDown->AddMenuItem(itemText, new KeyValues("SetText", "text", itemText), this, userData);
}
int FileCompletionEdit::AddItem(const wchar_t *itemText, KeyValues *userData)
{
// add the element to the menu
// when the menu item is selected it will send the custom message "SetText"
KeyValues *kv = new KeyValues("SetText");
kv->SetWString("text", itemText);
// get an ansi version for the menuitem name
char ansi[128];
g_pVGuiLocalize->ConvertUnicodeToANSI(itemText, ansi, sizeof(ansi));
return m_pDropDown->AddMenuItem(ansi, kv, this, userData);
}
void FileCompletionEdit::DeleteAllItems()
{
m_pDropDown->DeleteAllItems();
}
int FileCompletionEdit::GetItemCount()
{
return m_pDropDown->GetItemCount();
}
int FileCompletionEdit::GetItemIDFromRow(int row)
{
// valid from [0, GetItemCount)
return m_pDropDown->GetMenuID(row);
}
int FileCompletionEdit::GetRowFromItemID(int itemID)
{
int i;
for (i=0;i<GetItemCount();i++)
{
if (m_pDropDown->GetMenuID(i) == itemID)
return i;
}
return -1;
}
void FileCompletionEdit::PerformLayout()
{
BaseClass::PerformLayout();
m_pDropDown->PositionRelativeToPanel( this, Menu::DOWN, 0 );
// reset the width of the drop down menu to be the width of this edit box
m_pDropDown->SetFixedWidth(GetWide());
m_pDropDown->ForceCalculateWidth();
}
void FileCompletionEdit::OnSetText(const wchar_t *newtext)
{
// see if the combobox text has changed, and if so, post a message detailing the new text
wchar_t wbuf[255];
GetText( wbuf, 254 );
if ( wcscmp(wbuf, newtext) )
{
// text has changed
SetText(newtext);
// fire off that things have changed
PostActionSignal(new KeyValues("TextChanged", "text", newtext));
Repaint();
}
}
void FileCompletionEdit::OnKillFocus()
{
HideMenu();
BaseClass::OnKillFocus();
}
void FileCompletionEdit::HideMenu(void)
{
// hide the menu
m_pDropDown->SetVisible(false);
}
void FileCompletionEdit::ShowMenu(void)
{
// reset the dropdown's position
m_pDropDown->InvalidateLayout();
// make sure we're at the top of the draw order (and therefore our children as well)
// this important to make sure the menu will be drawn in the foreground
MoveToFront();
// reset the drop down
m_pDropDown->ClearCurrentlyHighlightedItem();
// limit it to only 6
if (m_pDropDown->GetItemCount() > 6)
{
m_pDropDown->SetNumberOfVisibleItems(6);
}
else
{
m_pDropDown->SetNumberOfVisibleItems(m_pDropDown->GetItemCount());
}
// show the menu
m_pDropDown->SetVisible(true);
Repaint();
}
void FileCompletionEdit::OnKeyCodeTyped(KeyCode code)
{
if ( code == KEY_DOWN )
{
if (m_pDropDown->GetItemCount() > 0)
{
int menuID = m_pDropDown->GetCurrentlyHighlightedItem();
int row = -1;
if ( menuID == -1 )
{
row = m_pDropDown->GetItemCount() - 1;
}
else
{
row = GetRowFromItemID(menuID);
}
row++;
if (row == m_pDropDown->GetItemCount())
{
row = 0;
}
menuID = GetItemIDFromRow(row);
m_pDropDown->SetCurrentlyHighlightedItem(menuID);
return;
}
}
else if ( code == KEY_UP )
{
if (m_pDropDown->GetItemCount() > 0)
{
int menuID = m_pDropDown->GetCurrentlyHighlightedItem();
int row = -1;
if ( menuID == -1 )
{
row = 0;
}
else
{
row = GetRowFromItemID(menuID);
}
row--;
if ( row < 0 )
{
row = m_pDropDown->GetItemCount() - 1;
}
menuID = GetItemIDFromRow(row);
m_pDropDown->SetCurrentlyHighlightedItem(menuID);
return;
}
}
else if ( code == KEY_ESCAPE )
{
if ( m_pDropDown->IsVisible() )
{
HideMenu();
return;
}
}
BaseClass::OnKeyCodeTyped(code);
return;
}
void FileCompletionEdit::OnMenuItemHighlight( int itemID )
{
char wbuf[80];
if ( m_pDropDown->IsValidMenuID(itemID) )
{
m_pDropDown->GetMenuItem(itemID)->GetText(wbuf, 80);
}
else
{
wbuf[0] = 0;
}
SetText(wbuf);
RequestFocus();
GotoTextEnd();
}
} // 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 )
{
m_bFileSelected = false;
SetTitle(title, true);
SetMinimizeButtonVisible(false);
#ifdef POSIX
Q_strncpy(m_szLastPath, "/", sizeof( m_szLastPath ) );
#else
Q_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_pFileNameEdit = new FileCompletionEdit(this);
m_pFileNameEdit->AddActionSignalTarget(this);
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" );
m_pFolderIcon = new ImagePanel(NULL, "FolderIcon");
// 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_pFileNameEdit->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_pFileNameEdit->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_pFileNameEdit);
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_pFileNameEdit->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 );
if ( !pLocalPath[0] || ( IsOSX() && V_strlen(pLocalPath) <= 2 ) )
{
const char *pszHomeDir = getenv( "HOME" );
V_strcpy_safe( pLocalPath, pszHomeDir );
}
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_pFolderIcon->SetImage(scheme()->GetImage("resource/icon_folder", false));
m_pFolderUpButton->AddImage(scheme()->GetImage("resource/icon_folderup", false), -3);
m_pNewFolderButton->AddImage( scheme()->GetImage("resource/icon_newfolder", false), -3 );
m_pOpenInExplorerButton->AddImage( scheme()->GetImage("resource/icon_play_once", false), -3 );
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();
#ifdef WIN32
// 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;
}
#else
m_pFullPathEdit->AddItem("/", NULL);
char *pData = fullpath;
int indent = 0;
while (*pData)
{
if (*pData == '/' && ( pData[1] != '\0' ) )
{
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++;
}
#endif
}
//-----------------------------------------------------------------------------
// 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_pFileNameEdit->SetText("");
m_pFileNameEdit->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( _X360 ) && defined( WIN32 )
ShellExecute( NULL, NULL, pCurrentDirectory, NULL, NULL, SW_SHOWNORMAL );
#elif defined( OSX )
char szCmd[ MAX_PATH * 2];
Q_snprintf( szCmd, sizeof(szCmd), "/usr/bin/open \"%s\"", pCurrentDirectory );
::system( szCmd );
#elif defined( LINUX )
char szCmd[ MAX_PATH * 2 ];
Q_snprintf( szCmd, sizeof(szCmd), "xdg-open \"%s\" &", pCurrentDirectory );
::system( szCmd );
#endif
}
//-----------------------------------------------------------------------------
// 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_pFileNameEdit->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_pFileNameEdit->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_pFileNameEdit->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);
Q_StripLastDir( fullpath, sizeof( fullpath ) );
// append a trailing slash
Q_AppendSlash( fullpath, sizeof( fullpath ) );
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
// cleanup the path, we format tabs into the list to make it pretty in the UI
Q_StripPrecedingAndTrailingWhitespace( fullpath );
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);
}
#ifdef WIN32
const char *GetAttributesAsString( DWORD dwAttributes )
{
static char out[ 256 ];
out[ 0 ] = 0;
if ( dwAttributes & FILE_ATTRIBUTE_ARCHIVE )
{
Q_strncat( out, "A", sizeof( out ), COPY_ALL_CHARACTERS );
}
if ( dwAttributes & FILE_ATTRIBUTE_COMPRESSED )
{
Q_strncat( out, "C", sizeof( out ), COPY_ALL_CHARACTERS );
}
if ( dwAttributes & FILE_ATTRIBUTE_DIRECTORY )
{
Q_strncat( out, "D", sizeof( out ), COPY_ALL_CHARACTERS );
}
if ( dwAttributes & FILE_ATTRIBUTE_HIDDEN )
{
Q_strncat( out, "H", sizeof( out ), COPY_ALL_CHARACTERS );
}
if ( dwAttributes & FILE_ATTRIBUTE_READONLY )
{
Q_strncat( out, "R", sizeof( out ), COPY_ALL_CHARACTERS );
}
if ( dwAttributes & FILE_ATTRIBUTE_SYSTEM )
{
Q_strncat( out, "S", sizeof( out ), COPY_ALL_CHARACTERS );
}
if ( dwAttributes & FILE_ATTRIBUTE_TEMPORARY )
{
Q_strncat( out, "T", sizeof( out ), COPY_ALL_CHARACTERS );
}
return out;
}
const char *GetFileTimetamp( FILETIME ft )
{
SYSTEMTIME local;
FILETIME localFileTime;
FileTimeToLocalFileTime( &ft, &localFileTime );
FileTimeToSystemTime( &localFileTime, &local );
static char out[ 256 ];
bool am = true;
WORD hour = local.wHour;
if ( hour >= 12 )
{
am = false;
// 12:42 pm displays as 12:42 pm
// 13:42 pm displays as 1:42 pm
if ( hour > 12 )
{
hour -= 12;
}
}
Q_snprintf( out, sizeof( out ), "%d/%02d/%04d %d:%02d %s",
local.wMonth,
local.wDay,
local.wYear,
hour,
local.wMinute,
am ? "AM" : "PM" // TODO: Localize this?
);
return out;
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Fill the filelist with the names of all the files in the current directory
//-----------------------------------------------------------------------------
#define MAX_FILTER_LENGTH 255
void FileOpenDialog::PopulateFileList()
{
// clear the current list
m_pFileList->DeleteAllItems();
FileFindHandle_t findHandle;
char pszFileModified[64];
// get the current directory
char currentDir[MAX_PATH * 4];
char dir[MAX_PATH * 4];
char filterList[MAX_FILTER_LENGTH+1];
GetCurrentDirectory(currentDir, sizeof(dir));
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 )
|| !IsOSX()
|| ( IsOSX() && g_pFullFileSystem->FindIsDirectory( findHandle ) && Q_stristr( pszFileName, ".app" ) ) )
{
char pFullPath[MAX_PATH];
Q_snprintf( pFullPath, MAX_PATH, "%s%s", currentDir, pszFileName );
// add the file to the list
kv->SetString( "text", pszFileName );
kv->SetInt( "image", 1 );
IImage *image = surface()->GetIconImageForFullPath( pFullPath );
if ( image )
{
kv->SetPtr( "iconImage", (void *)image );
}
kv->SetInt("imageSelected", 1);
kv->SetInt("directory", 0);
kv->SetString( "filesize", Q_pretifymem( g_pFullFileSystem->Size( pFullPath ), 0, true ) );
Q_FixSlashes( pFullPath );
wchar_t fileType[ 80 ];
g_pFullFileSystem->GetFileTypeForFullPath( pFullPath, fileType, sizeof( fileType ) );
kv->SetWString( "type", fileType );
kv->SetString( "attributes", g_pFullFileSystem->IsFileWritable( pFullPath )? "" : "R" );
time_t fileModified = g_pFullFileSystem->GetFileTime( pFullPath );
g_pFullFileSystem->FileTimeToString( pszFileModified, sizeof( pszFileModified ), fileModified );
kv->SetString( "modified", pszFileModified );
// kv->SetString( "created", GetFileTimetamp( findData.ftCreationTime ) );
m_pFileList->AddItem(kv, 0, false, false);
}
pszFileName = g_pFullFileSystem->FindNext( findHandle );
}
g_pFullFileSystem->FindClose( findHandle );
}
}
// find all the directories
GetCurrentDirectory( dir, sizeof(dir) );
Q_strncat(dir, "*", sizeof( dir ), COPY_ALL_CHARACTERS);
const char *pszFileName = g_pFullFileSystem->FindFirst( dir, &findHandle );
while ( pszFileName )
{
if ( pszFileName[0] != '.' && g_pFullFileSystem->FindIsDirectory( findHandle )
&& ( !IsOSX() || ( IsOSX() && !Q_stristr( pszFileName, ".app" ) ) ) )
{
char pFullPath[MAX_PATH];
Q_snprintf( pFullPath, MAX_PATH, "%s%s", currentDir, pszFileName );
kv->SetString("text", pszFileName );
kv->SetPtr( "iconImage", (void *)NULL );
kv->SetInt("image", 2);
kv->SetInt("imageSelected", 3);
kv->SetInt("directory", 1);
kv->SetString( "filesize", "" );
kv->SetString( "type", "#FileOpenDialog_FileType_Folder" );
kv->SetString( "attributes", g_pFullFileSystem->IsFileWritable( pFullPath )? "" : "R" );
time_t fileModified = g_pFullFileSystem->GetFileTime( pFullPath );
g_pFullFileSystem->FileTimeToString( pszFileModified, sizeof( pszFileModified ), fileModified );
kv->SetString( "modified", pszFileModified );
// kv->SetString( "created", GetFileTimetamp( findData.ftCreationTime ) );
m_pFileList->AddItem( kv, 0, false, false );
}
pszFileName = g_pFullFileSystem->FindNext( findHandle );
}
g_pFullFileSystem->FindClose( findHandle );
kv->deleteThis();
m_pFileList->SortList();
}
//-----------------------------------------------------------------------------
// 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_pFileNameEdit->SetText("");
return;
}
if ( !stricmp(pFileName, ".") )
{
// clear the name text
m_pFileNameEdit->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] == '\\' ) && (!IsOSX() || ( IsOSX() && !Q_stristr( pFileName, ".app" ) ) );
Q_StripTrailingSlash( pFileName );
if ( !stricmp(pFileName, "..") )
{
MoveUpFolder();
// clear the name text
m_pFileNameEdit->SetText("");
return;
}
if ( !stricmp(pFileName, ".") )
{
// clear the name text
m_pFileNameEdit->SetText("");
return;
}
// Compute the full path
char pFullPath[MAX_PATH * 4];
if ( !Q_IsAbsolutePath( pFileName ) )
{
GetCurrentDirectory(pFullPath, sizeof(pFullPath) - MAX_PATH);
Q_AppendSlash( pFullPath, sizeof( pFullPath ) );
strcat(pFullPath, pFileName);
if ( !pFileName[0] )
{
Q_StripTrailingSlash( pFullPath );
}
}
else
{
Q_strncpy( pFullPath, pFileName, sizeof(pFullPath) );
}
Q_StripTrailingSlash( pFullPath );
// 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( pFullPath ) == 2 )
{
Q_AppendSlash( pFullPath, Q_ARRAYSIZE( pFullPath ) );
}
#endif
// If the name specified is a directory, then change directory
if ( g_pFullFileSystem->IsDirectory( pFullPath, NULL ) &&
( !IsOSX() || ( IsOSX() && !Q_stristr( pFullPath, ".app" ) ) ) )
{
// it's a directory; change to the specified directory
if ( !bSpecifiedDirectory )
{
Q_AppendSlash( pFullPath, Q_ARRAYSIZE( pFullPath ) );
}
SetStartDirectory( pFullPath );
// clear the name text
m_pFileNameEdit->SetText("");
m_pFileNameEdit->HideMenu();
PopulateDriveList();
PopulateFileList();
InvalidateLayout();
return;
}
else if ( bSpecifiedDirectory )
{
PopulateDriveList();
PopulateFileList();
InvalidateLayout();
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::PopulateFileNameCompletion()
{
char buf[80];
m_pFileNameEdit->GetText(buf, 80);
wchar_t wbuf[80];
m_pFileNameEdit->GetText(wbuf, 80);
int bufLen = wcslen(wbuf);
// delete all items before we check if there's even a string
m_pFileNameEdit->DeleteAllItems();
// no string at all - don't show even bother showing it
if (bufLen == 0)
{
m_pFileNameEdit->HideMenu();
return;
}
// what files use current string as a prefix?
int nCount = m_pFileList->GetItemCount();
int i;
for ( i = 0 ; i < nCount ; i++ )
{
KeyValues *kv = m_pFileList->GetItem(m_pFileList->GetItemIDFromRow(i));
const wchar_t *wszString = kv->GetWString("text");
if ( !_wcsnicmp(wbuf, wszString, bufLen) )
{
m_pFileNameEdit->AddItem(wszString, NULL);
}
}
// if there are any items - show the menu
if ( m_pFileNameEdit->GetItemCount() > 0 )
{
m_pFileNameEdit->ShowMenu();
}
else
{
m_pFileNameEdit->HideMenu();
}
m_pFileNameEdit->InvalidateLayout();
}
//-----------------------------------------------------------------------------
// 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_pFileNameEdit->SetText("");
}
else
{
// put the file name into the text edit box
KeyValues *data = m_pFileList->GetItem(m_pFileList->GetSelectedItem(0));
m_pFileNameEdit->SetText(data->GetString("text"));
}
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// 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_pFileNameEdit->HideMenu();
m_pFileNameEdit->SetText("");
OnOpen();
}
else if (pPanel == m_pFileNameEdit)
{
PopulateFileNameCompletion();
}
else if (pPanel == m_pFileTypeCombo)
{
m_pFileNameEdit->HideMenu();
PopulateFileList();
}
}