1702 lines
47 KiB
C++
1702 lines
47 KiB
C++
//========= 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
|
|
|
|
// 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" );
|
|
|
|
long 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" );
|
|
|
|
long 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();
|
|
}
|
|
}
|