CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Source/Developer/SlateFileDialogs/Private/SlateFileDlgWindow.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

1819 lines
46 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "SlateFileDlgWindow.h"
#include "SlateFileDialogsPrivate.h"
#include "HAL/PlatformProcess.h"
#include "GenericPlatform/GenericPlatformFile.h"
#include "HAL/PlatformFileManager.h"
#include "HAL/FileManager.h"
#include "Modules/ModuleManager.h"
#include "Widgets/SWindow.h"
#include "Framework/Application/SlateApplication.h"
#include "Textures/SlateIcon.h"
#include "Framework/Commands/UIAction.h"
#include "Framework/Docking/TabManager.h"
#include "Widgets/Layout/SSpacer.h"
#include "Framework/MultiBox/MultiBoxBuilder.h"
#include "Widgets/Input/SButton.h"
#include "Widgets/Input/STextComboBox.h"
#include "Widgets/Navigation/SBreadcrumbTrail.h"
#include "Widgets/Text/SInlineEditableTextBlock.h"
#include "DirectoryWatcherModule.h"
#if PLATFORM_WINDOWS
#include "Windows/WindowsHWrapper.h"
#endif
#define LOCTEXT_NAMESPACE "SlateFileDialogsNamespace"
DEFINE_LOG_CATEGORY_STATIC(LogSlateFileDialogs, Log, All);
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class FSlateFileDialogVisitor : public IPlatformFile::FDirectoryVisitor
{
public:
FSlateFileDialogVisitor(TArray<TSharedPtr<FFileEntry>> &InFileList,
TArray<TSharedPtr<FFileEntry>> &InFolderList, const FString& InFilterList)
: FileList(InFileList),
FolderList(InFolderList)
{
// Process the filters once rather than once for each file encountered
InFilterList.ParseIntoArray(FilterList, TEXT(";"), true);
// Remove cruft from the extension list
for (int32 Index = 0; Index < FilterList.Num(); Index++)
{
FilterList[Index].ReplaceInline(TEXT(")"), TEXT(""));
FilterList[Index] = FilterList[Index].TrimQuotes().TrimStartAndEnd();
}
}
virtual bool Visit(const TCHAR* FilenameOrDirectory, bool bIsDirectory) override
{
int32 i;
// break filename from path
for (i = FCString::Strlen(FilenameOrDirectory) - 1; i >= 0; i--)
{
if (FilenameOrDirectory[i] == TCHAR('/'))
{
break;
}
}
#if HIDE_HIDDEN_FILES
if (FilenameOrDirectory[i + 1] == TCHAR('.'))
{
return true;
}
#endif
FDateTime stamp = IFileManager::Get().GetTimeStamp(FilenameOrDirectory);
FString ModDate = "";
FString FileSize = "";
if (bIsDirectory)
{
FolderList.Add(MakeShareable(new FFileEntry(FString(&FilenameOrDirectory[i + 1]), ModDate, FileSize, true)));
}
else
{
if (PassesFilterTest(&FilenameOrDirectory[i + 1]))
{
int64 size = IFileManager::Get().FileSize(FilenameOrDirectory);
if (size < 1048576)
{
size = (size + 1023) / 1024;
FileSize = FString::FromInt(size) + " KB";
}
else
{
size /= 1024;
if (size < 1048576)
{
size = (size + 1023) / 1024;
FileSize = FString::FromInt(size) + " MB";
}
else
{
size /= 1024;
size = (size + 1023) / 1024;
FileSize = FString::FromInt(size) + " GB";
}
}
ModDate = FString::Printf(TEXT("%02d/%02d/%04d "), stamp.GetMonth(), stamp.GetDay(), stamp.GetYear());
if (stamp.GetHour() == 0)
{
ModDate = ModDate + FString::Printf(TEXT("12:%02d AM"), stamp.GetMinute());
}
else if (stamp.GetHour() < 12)
{
ModDate = ModDate + FString::Printf(TEXT("%2d:%02d AM"), stamp.GetHour12(), stamp.GetMinute());
}
else
{
ModDate = ModDate + FString::Printf(TEXT("%2d:%02d PM"), stamp.GetHour12(), stamp.GetMinute());
}
FileList.Add(MakeShareable(new FFileEntry(FString(&FilenameOrDirectory[i + 1]), ModDate, FileSize, false)));
}
}
return true;
}
bool PassesFilterTest(const TCHAR* Filename)
{
if (FilterList.Num() == 0)
{
return true; // no filters. everything passes.
}
FString BaseFile = Filename;
FString Extension = FPaths::GetExtension(BaseFile, true);
if (!Extension.IsEmpty() && FCString::IsNumeric(*Extension))
{
BaseFile.LeftChopInline(Extension.Len());
const int32 DotPos = BaseFile.Find(TEXT("."), ESearchCase::CaseSensitive, ESearchDir::FromEnd);
if (DotPos != INDEX_NONE)
{
Extension = BaseFile.Right(DotPos);
Extension += TEXT(".*");
}
}
// See if it matches any of the extensions
for (const FString& FilterExt : FilterList)
{
if (FilterExt == TEXT("*") || FilterExt == TEXT(".*") || FilterExt == TEXT("*.*") || FilterExt.EndsWith(Extension))
{
return true;
}
}
return false;
}
private:
TArray<TSharedPtr<FFileEntry>>& FileList;
TArray<TSharedPtr<FFileEntry>>& FolderList;
TArray<FString> FilterList;
};
class FSlateFileDialogDirVisitor : public IPlatformFile::FDirectoryVisitor
{
public:
FSlateFileDialogDirVisitor(TArray<FString> *InDirectoryNames)
: DirectoryNames(InDirectoryNames)
{}
void SetResultPath(TArray<FString> *InDirectoryNames) { DirectoryNames = InDirectoryNames; }
virtual bool Visit(const TCHAR* FilenameOrDirectory, bool bIsDirectory) override
{
int32 i;
// break filename from path
for (i = FCString::Strlen(FilenameOrDirectory) - 1; i >= 0; i--)
{
if (FilenameOrDirectory[i] == TCHAR('/'))
break;
}
#if HIDE_HIDDEN_FILES
if (FilenameOrDirectory[i + 1] == TCHAR('.'))
{
return true;
}
#endif
if (bIsDirectory)
{
DirectoryNames->Add(FString(&FilenameOrDirectory[i + 1]));
}
return true;
}
private:
TArray<FString> *DirectoryNames;
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
FSlateFileDlgWindow::FSlateFileDlgWindow(FSlateFileDialogsStyle *InStyleSet)
{
StyleSet = InStyleSet;
}
namespace
{
TSharedPtr<SWindow> FindMatchingWindowImpl(const TArray<TSharedRef<SWindow>>& RootWindows, const TFunctionRef<bool(const TSharedRef<SWindow>&)> Predicate)
{
for (const TSharedRef<SWindow>& Window : RootWindows)
{
if (Predicate(Window))
{
return Window;
}
if (TSharedPtr<SWindow> ChildWindow = FindMatchingWindowImpl(Window->GetChildWindows(), Predicate))
{
return ChildWindow;
}
}
return nullptr;
}
TSharedPtr<SWindow> FindMatchingWindow(const TFunctionRef<bool(const TSharedRef<SWindow>&)> Predicate)
{
return FindMatchingWindowImpl(FSlateApplication::Get().GetTopLevelWindows(), Predicate);
}
TSharedPtr<const SWidget> GetParentWindowWidget(const void* ParentWindowHandle)
{
if (ParentWindowHandle)
{
TSharedPtr<SWindow> ParentWindow = FindMatchingWindow([ParentWindowHandle](const TSharedRef<SWindow>& Window)
{
const TSharedPtr<FGenericWindow> NativeWindow = Window->GetNativeWindow();
return NativeWindow && NativeWindow->GetOSWindowHandle() == ParentWindowHandle;
});
if (ParentWindow)
{
return ParentWindow;
}
}
return FGlobalTabmanager::Get()->GetRootWindow();
}
}
bool FSlateFileDlgWindow::OpenFileDialog(const void* ParentWindowHandle, const FString& DialogTitle, const FString& DefaultPath,
const FString& DefaultFile, const FString& FileTypes, uint32 Flags, TArray<FString>& OutFilenames, int32& OutFilterIndex,
int32 DefaultFilterIndex)
{
FString StartDirectory = DefaultPath;
TrimFilenameFromPath(StartDirectory);
TSharedRef<SWindow> ModalWindow = SNew(SWindow)
.SupportsMinimize(false)
.SupportsMaximize(false)
.Title(LOCTEXT("SlateFileDialogsOpenFile","Open File"))
.CreateTitleBar(true)
.MinHeight(400.0f)
.MinWidth(600.0f)
.ActivationPolicy(EWindowActivationPolicy::Always)
.ClientSize(FVector2D(800, 500));
DialogWidget = SNew(SSlateFileOpenDlg)
.bMultiSelectEnabled(Flags == 1)
.ParentWindow(ModalWindow)
.CurrentPath(StartDirectory)
.Filters(FileTypes)
.WindowTitleText(DialogTitle)
.StyleSet(StyleSet);
DialogWidget->SetOutNames(&OutFilenames);
DialogWidget->SetOutFilterIndex(&OutFilterIndex);
DialogWidget->SetDefaultFilterIndex(DefaultFilterIndex);
ModalWindow->SetContent( DialogWidget.ToSharedRef() );
FSlateApplication::Get().AddModalWindow(ModalWindow, GetParentWindowWidget(ParentWindowHandle));
return (DialogWidget->GetResponse() == EResult::Accept && OutFilenames.Num() > 0);
}
bool FSlateFileDlgWindow::OpenFileDialog(const void* ParentWindowHandle, const FString& DialogTitle, const FString& DefaultPath,
const FString& DefaultFile, const FString& FileTypes, uint32 Flags, TArray<FString>& OutFilenames)
{
int32 DummyIndex;
return OpenFileDialog(ParentWindowHandle, DialogTitle, DefaultPath, DefaultFile, FileTypes, Flags, OutFilenames, DummyIndex);
}
bool FSlateFileDlgWindow::OpenDirectoryDialog(const void* ParentWindowHandle, const FString& DialogTitle, const FString& DefaultPath,
FString& OutFoldername)
{
int32 DummyIndex;
TArray<FString> TempOut;
FString Filters = "";
FString StartDirectory = DefaultPath;
TrimFilenameFromPath(StartDirectory);
TSharedRef<SWindow> ModalWindow = SNew(SWindow)
.SupportsMinimize(false)
.SupportsMaximize(false)
.Title(LOCTEXT("SlateFileDialogsOpenDirectory","Open Directory"))
.CreateTitleBar(true)
.MinHeight(400.0f)
.MinWidth(600.0f)
.ActivationPolicy(EWindowActivationPolicy::Always)
.ClientSize(FVector2D(800, 500));
DialogWidget = SNew(SSlateFileOpenDlg)
.bMultiSelectEnabled(false)
.ParentWindow(ModalWindow)
.bDirectoriesOnly(true)
.CurrentPath(StartDirectory)
.WindowTitleText(DialogTitle)
.StyleSet(StyleSet);
DialogWidget->SetOutNames(&TempOut);
DialogWidget->SetOutFilterIndex(&DummyIndex);
ModalWindow->SetContent( DialogWidget.ToSharedRef() );
FSlateApplication::Get().AddModalWindow(ModalWindow, GetParentWindowWidget(ParentWindowHandle));
bool RC = (DialogWidget->GetResponse() == EResult::Accept && TempOut.Num() > 0);
if (TempOut.Num() > 0)
{
OutFoldername = FPaths::ConvertRelativePathToFull(TempOut[0]);
if (!OutFoldername.EndsWith(TEXT("/")))
{
OutFoldername += TEXT("/");
}
}
return RC;
}
bool FSlateFileDlgWindow::SaveFileDialog(const void* ParentWindowHandle, const FString& DialogTitle, const FString& DefaultPath,
const FString& DefaultFile, const FString& FileTypes, uint32 Flags, TArray<FString>& OutFilenames, int32& OutFilterIndex,
int32 DefaultFilterIndex)
{
FString StartDirectory = DefaultPath;
TrimFilenameFromPath(StartDirectory);
TSharedRef<SWindow> ModalWindow = SNew(SWindow)
.SupportsMinimize(false)
.SupportsMaximize(false)
.Title(LOCTEXT("SlateFileDialogsSaveFile","Save File"))
.CreateTitleBar(true)
.MinHeight(400.0f)
.MinWidth(600.0f)
.ActivationPolicy(EWindowActivationPolicy::Always)
.ClientSize(FVector2D(800, 500));
DialogWidget = SNew(SSlateFileOpenDlg)
.bMultiSelectEnabled(false)
.ParentWindow(ModalWindow)
.bSaveFile(true)
.AcceptText(LOCTEXT("SlateFileDialogsSave","Save"))
.CurrentPath(StartDirectory)
.Filters(FileTypes)
.WindowTitleText(DialogTitle)
.StyleSet(StyleSet);
DialogWidget->SetOutNames(&OutFilenames);
DialogWidget->SetOutFilterIndex(&OutFilterIndex);
DialogWidget->SetDefaultFilterIndex(DefaultFilterIndex);
DialogWidget->SetDefaultFile(DefaultFile);
ModalWindow->SetContent( DialogWidget.ToSharedRef() );
FSlateApplication::Get().AddModalWindow(ModalWindow, GetParentWindowWidget(ParentWindowHandle));
return (DialogWidget->GetResponse() == EResult::Accept && OutFilenames.Num() > 0);
}
bool FSlateFileDlgWindow::SaveFileDialog(const void* ParentWindowHandle, const FString& DialogTitle, const FString& DefaultPath,
const FString& DefaultFile, const FString& FileTypes, uint32 Flags, TArray<FString>& OutFilenames)
{
int32 DummyIndex;
return SaveFileDialog(ParentWindowHandle, DialogTitle, DefaultPath, DefaultFile, FileTypes, Flags, OutFilenames, DummyIndex);
}
void FSlateFileDlgWindow::TrimFilenameFromPath(FString &InPath)
{
if (InPath.Len() == 0 || !FPaths::FileExists(InPath))
{
// No path given OR no file portion to trim
return;
}
FPaths::CollapseRelativeDirectories(InPath);
FString PathPart;
FString FileNamePart;
FString ExtensionPart;
FPaths::Split(InPath, PathPart, FileNamePart, ExtensionPart);
InPath = PathPart;
}
//-----------------------------------------------------------------------------
// custom file dialog widget
//-----------------------------------------------------------------------------
BEGIN_SLATE_FUNCTION_BUILD_OPTIMIZATION
void SSlateFileOpenDlg::Construct(const FArguments& InArgs)
{
CurrentPath = InArgs._CurrentPath;
Filters = InArgs._Filters;
bMultiSelectEnabled = InArgs._bMultiSelectEnabled;
bDirectoriesOnly = InArgs._bDirectoriesOnly;
bSaveFile = InArgs._bSaveFile;
WindowTitleText = InArgs._WindowTitleText;
OutNames = InArgs._OutNames;
OutFilterIndex = InArgs._OutFilterIndex;
UserResponse = FSlateFileDlgWindow::Cancel;
ParentWindow = InArgs._ParentWindow;
StyleSet = InArgs._StyleSet;
AcceptText = InArgs._AcceptText;
DirNodeIndex = -1;
FilterIndex = 0;
ESelectionMode::Type SelectMode = bMultiSelectEnabled ? ESelectionMode::Multi : ESelectionMode::Single;
struct EVisibility SaveFilenameVisibility = bDirectoriesOnly ? EVisibility::Collapsed : EVisibility::Visible;
this->ChildSlot
[
SNew(SBorder)
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.Padding(FMargin(20.0f,20.0f))
.BorderImage(StyleSet->GetBrush("SlateFileDialogs.GroupBorder"))
[
SNew(SVerticalBox)
+ SVerticalBox::Slot() // window title
.HAlign(HAlign_Left)
.VAlign(VAlign_Fill)
.AutoHeight()
.Padding(FMargin(0.0f, 0.0f, 0.0f, 20.0f))
[
SAssignNew(WindowTitle, STextBlock)
.Text(FText::FromString(WindowTitleText))
.Font(StyleSet->GetFontStyle("SlateFileDialogs.DialogLarge"))
.Justification(ETextJustify::Center)
]
+ SVerticalBox::Slot() // Path breadcrumbs
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.AutoHeight()
.Padding(FMargin(0.0f, 0.0f, 0.0f, 10.0f))
[
SAssignNew(PathBreadcrumbTrail, SBreadcrumbTrail<FString>)
.ButtonContentPadding(FMargin(2.0f, 2.0f))
.ButtonStyle(StyleSet->Get(), "SlateFileDialogs.FlatButton")
.DelimiterImage(StyleSet->GetBrush("SlateFileDialogs.PathDelimiter"))
.TextStyle(StyleSet->Get(), "SlateFileDialogs.PathText")
.ShowLeadingDelimiter(false)
.OnCrumbClicked(this, &SSlateFileOpenDlg::OnPathClicked)
.GetCrumbMenuContent(this, &SSlateFileOpenDlg::OnGetCrumbDelimiterContent)
.AddMetaData<FTagMetaData>(FTagMetaData(TEXT("ContentBrowserPath")))
]
+ SVerticalBox::Slot() // new directory
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.AutoHeight()
.Padding(FMargin(0.0f, 0.0f, 0.0f, 10.0f))
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.Padding(FMargin(0.0f, 0.0f, 10.0f, 0.0f))
.AutoWidth()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
[
SNew(SButton)
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.OnClicked(this, &SSlateFileOpenDlg::OnGoBackClick)
.ContentPadding(FMargin(0.0f))
[
SNew(SImage)
.Image(StyleSet->GetBrush("SlateFileDialogs.BrowseBack24"))
]
]
+ SHorizontalBox::Slot()
.Padding(FMargin(0.0f, 0.0f, 40.0f, 0.0f))
.AutoWidth()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
[
SNew(SButton)
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.OnClicked(this, &SSlateFileOpenDlg::OnGoForwardClick)
.ContentPadding(FMargin(0.0f))
[
SNew(SImage)
.Image(StyleSet->GetBrush("SlateFileDialogs.BrowseForward24"))
]
]
+ SHorizontalBox::Slot()
.Padding(FMargin(0.0f))
.AutoWidth()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
[
SNew(SButton)
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.OnClicked(this, &SSlateFileOpenDlg::OnNewDirectoryClick)
.ContentPadding(FMargin(0.0f))
[
SNew(SImage)
.Image(StyleSet->GetBrush("SlateFileDialogs.NewFolder24"))
]
]
+ SHorizontalBox::Slot()
.Padding(FMargin(20.0f, 0.0f, 0.0f, 0.0f))
.AutoWidth()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
[
SAssignNew(NewDirectorySizeBox, SBox)
.Padding(FMargin(0.0f))
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.WidthOverride(300.0f)
.Visibility(EVisibility::Hidden)
[
SNew(SBorder)
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.Padding(FMargin(5.0f,0.0f))
.BorderBackgroundColor(FLinearColor(0.1f, 0.1f, 0.1f, 1.0f))
.BorderImage(StyleSet->GetBrush("SlateFileDialogs.WhiteBackground"))
[
SAssignNew(NewDirectoryEditBox, SInlineEditableTextBlock)
.Font(StyleSet->GetFontStyle("SlateFileDialogs.Dialog"))
.IsReadOnly(false)
.Text(FText::GetEmpty())
.OnTextCommitted(this, &SSlateFileOpenDlg::OnNewDirectoryCommitted)
.OnVerifyTextChanged(this, &SSlateFileOpenDlg::OnNewDirectoryTextChanged)
]
]
]
+ SHorizontalBox::Slot()
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.Padding(FMargin(20.0f, 0.0f, 0.0f, 0.0f))
.AutoWidth()
[
SAssignNew(NewDirCancelButton, SButton)
.ContentPadding(FMargin(5.0f, 5.0f))
.OnClicked(this, &SSlateFileOpenDlg::OnNewDirectoryAcceptCancelClick, FSlateFileDlgWindow::Cancel)
.Text(LOCTEXT("SlateFileDialogsCancel","Cancel"))
.Visibility(EVisibility::Hidden)
]
]
+ SVerticalBox::Slot() // new directory
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.AutoHeight()
.Padding(FMargin(0.0f, 0.0f, 0.0f, 10.0f))
[
SAssignNew(DirErrorMsg, STextBlock)
.Font(StyleSet->GetFontStyle("SlateFileDialogs.DialogBold"))
.Justification(ETextJustify::Left)
.ColorAndOpacity(FLinearColor::Yellow)
.Text(LOCTEXT("SlateFileDialogsDirError", "Unable to create directory!"))
.Visibility(EVisibility::Collapsed)
]
+ SVerticalBox::Slot()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.FillHeight(1.0f)
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.Padding(FMargin(0.0f))
.AutoWidth()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
[
SNew(SVerticalBox)
+ SVerticalBox::Slot()
.Padding(FMargin(10.0f))
.AutoHeight()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
[
SNew(SButton)
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.OnClicked(this, &SSlateFileOpenDlg::OnQuickLinkClick, FSlateFileDlgWindow::Project)
.ContentPadding(FMargin(2.0f))
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.AutoWidth()
[
SNew(SImage)
.Image(StyleSet->GetBrush("SlateFileDialogs.Folder24"))
]
+ SHorizontalBox::Slot()
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.AutoWidth()
[
SNew(STextBlock)
.Text(LOCTEXT("ProjectsLabel", "Projects"))
.Font(StyleSet->GetFontStyle("SlateFileDialogs.Dialog"))
.Justification(ETextJustify::Left)
]
]
]
+ SVerticalBox::Slot()
.Padding(FMargin(10.0f))
.AutoHeight()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
[
SNew(SButton)
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.OnClicked(this, &SSlateFileOpenDlg::OnQuickLinkClick, FSlateFileDlgWindow::Engine)
.ContentPadding(FMargin(2.0f))
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.AutoWidth()
[
SNew(SImage)
.Image(StyleSet->GetBrush("SlateFileDialogs.Folder24"))
]
+ SHorizontalBox::Slot()
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.AutoWidth()
[
SNew(STextBlock)
.Text(LOCTEXT("EngineLabel", "Engine"))
.Font(StyleSet->GetFontStyle("SlateFileDialogs.Dialog"))
.Justification(ETextJustify::Left)
]
]
]
]
+ SHorizontalBox::Slot() // spacer
.Padding(FMargin(0.0f))
.AutoWidth()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
[
SNew(SSpacer)
.Size(FVector2D(20.0f, 1.0f))
]
+ SHorizontalBox::Slot() // file list area
.Padding(FMargin(0.0f, 0.0f, 20.0f, 0.0f))
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.FillWidth(1.0f)
[
SNew(SBorder)
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.Padding(FMargin(10.0f))
.BorderBackgroundColor(FLinearColor(0.10f, 0.10f, 0.10f, 1.0f))
.BorderImage(StyleSet->GetBrush("SlateFileDialogs.WhiteBackground"))
[
SAssignNew(ListView, SListView<TSharedPtr<FFileEntry>>) // file list scroll
.ListItemsSource(&LineItemArray)
.SelectionMode(SelectMode)
.OnGenerateRow(this, &SSlateFileOpenDlg::OnGenerateWidgetForList)
.OnMouseButtonDoubleClick(this, &SSlateFileOpenDlg::OnItemDoubleClicked)
.OnSelectionChanged(this, &SSlateFileOpenDlg::OnItemSelected)
.HeaderRow
(
SNew(SHeaderRow)
.Visibility(EVisibility::Visible)
+ SHeaderRow::Column("Pathname")
.DefaultLabel(LOCTEXT("SlateFileDialogsNameHeader", "Name"))
.FillWidth(1.0f)
+ SHeaderRow::Column("ModDate")
.DefaultLabel(LOCTEXT("SlateFileDialogsModDateHeader", "Date Modified"))
.FixedWidth(170.0f)
+ SHeaderRow::Column("FileSize")
.DefaultLabel(LOCTEXT("SlateFileDialogsFileSizeHeader", "File Size"))
.FixedWidth(70.0f)
)
]
]
]
+ SVerticalBox::Slot() // save filename entry
.HAlign(HAlign_Right)
.VAlign(VAlign_Bottom)
.Padding(FMargin(0.0f, 10.0f, 50.0f, 0.0f))
.AutoHeight()
[
SAssignNew(SaveFilenameSizeBox, SBox)
.Padding(FMargin(0.0f))
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.MinDesiredHeight(20.0f)
.Visibility(SaveFilenameVisibility)
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.Padding(FMargin(0.0f))
.AutoWidth()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
[
SNew(STextBlock)
.Text(LOCTEXT("FilenameLabel", "Filename:"))
.Font(StyleSet->GetFontStyle("SlateFileDialogs.Dialog"))
.Justification(ETextJustify::Left)
]
+ SHorizontalBox::Slot()
.Padding(FMargin(10.0f, 0.0f, 0.0f, 0.0f))
.AutoWidth()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
[
SNew(SBox)
.Padding(FMargin(0.0f))
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.WidthOverride(300.0f)
[
SNew(SBorder)
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.Padding(FMargin(5.0f,0.0f))
.BorderBackgroundColor(FLinearColor(0.1f, 0.1f, 0.1f, 1.0f))
.BorderImage(StyleSet->GetBrush("SlateFileDialogs.WhiteBackground"))
[
SAssignNew(SaveFilenameEditBox, SInlineEditableTextBlock)
.Font(StyleSet->GetFontStyle("SlateFileDialogs.Dialog"))
.IsReadOnly(false)
.Text(FText::GetEmpty())
.OnTextCommitted(this, &SSlateFileOpenDlg::OnFileNameCommitted)
]
]
]
]
]
+ SVerticalBox::Slot() // cancel:accept buttons
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.AutoHeight()
.Padding(FMargin(0.0f, 10.0f, 0.0f, 0.0f))
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.Padding(FMargin(0.0f))
.AutoWidth()
.HAlign(HAlign_Left)
.VAlign(VAlign_Top)
[
SAssignNew(FilterHBox, SHorizontalBox)
+ SHorizontalBox::Slot()
.HAlign(HAlign_Left)
.VAlign(VAlign_Bottom)
.AutoWidth()
.Padding(FMargin(0.0f))
[
SNew(STextBlock)
.Text(bSaveFile ? LOCTEXT("SaveTypeLabel", "Save as type:") : LOCTEXT("FilterLabel", "Filter:"))
.Font(StyleSet->GetFontStyle("SlateFileDialogs.Dialog"))
.Justification(ETextJustify::Left)
]
+ SHorizontalBox::Slot()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.AutoWidth()
.Padding(FMargin(10.0f, 0.0f, 0.0f, 0.0f))
[
SNew(SBox)
.MinDesiredWidth(200.0f)
.MaxDesiredWidth(200.0f)
.Padding(FMargin(0.0f))
[
SAssignNew(FilterCombo, SComboBox<TSharedPtr<FString>>)
.ContentPadding(FMargin(4.0f, 2.0f))
.OptionsSource(&FilterNameArray)
.OnGenerateWidget_Lambda([this](TSharedPtr<FString> Item)
{
return SNew(SBox)
.MaxDesiredWidth(600.0f)
[
SNew(STextBlock)
.Text(FText::FromString(*Item))
.Font(StyleSet->GetFontStyle("SlateFileDialogs.Dialog"))
];
} )
.OnSelectionChanged(this, &SSlateFileOpenDlg::OnFilterChanged)
[
SAssignNew(FilterComboBoxTitleBlock, STextBlock)
]
]
]
]
+ SHorizontalBox::Slot()
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.FillWidth(1.0f)
[
SNew(SSpacer)
.Size(FVector2D(1.0f, 1.0f))
]
+ SHorizontalBox::Slot()
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.Padding(FMargin(0.0f, 0.0f, 20.0f, 0.0f))
.AutoWidth()
[
SNew(SButton)
.ContentPadding(FMargin(5.0f, 5.0f))
.IsEnabled(this, &SSlateFileOpenDlg::IsAcceptEnabled)
.OnClicked(this, &SSlateFileOpenDlg::OnAcceptCancelClick, FSlateFileDlgWindow::Accept)
.Text(AcceptText)
]
+ SHorizontalBox::Slot()
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.Padding(FMargin(0.0f))
.AutoWidth()
[
SNew(SButton)
.ContentPadding(FMargin(5.0f, 5.0f))
.OnClicked(this, &SSlateFileOpenDlg::OnAcceptCancelClick, FSlateFileDlgWindow::Cancel)
.Text(LOCTEXT("SlateFileDialogsCancel","Cancel"))
]
]
]
];
SaveFilename = "";
bNeedsBuilding = true;
bRebuildDirPath = true;
bDirectoryHasChanged = false;
DirectoryWatcher = nullptr;
if (CurrentPath.Len() > 0 && !CurrentPath.EndsWith("/"))
{
CurrentPath = CurrentPath + TEXT("/");
}
HistoryIndex = 0;
History.Add(CurrentPath);
#if ENABLE_DIRECTORY_WATCHER
if (!FModuleManager::Get().IsModuleLoaded("DirectoryWatcher"))
{
FModuleManager::Get().LoadModule("DirectoryWatcher");
}
FDirectoryWatcherModule &DirWatcherModule = FModuleManager::LoadModuleChecked<FDirectoryWatcherModule>(TEXT("DirectoryWatcher"));
DirectoryWatcher = DirWatcherModule.Get();
#endif
}
END_SLATE_FUNCTION_BUILD_OPTIMIZATION
SSlateFileOpenDlg::~SSlateFileOpenDlg()
{
if (DirectoryWatcher && RegisteredPath.Len() > 0)
{
DirectoryWatcher->UnregisterDirectoryChangedCallback_Handle(RegisteredPath, OnDialogDirectoryChangedDelegateHandle);
}
}
void SSlateFileOpenDlg::BuildDirectoryPath()
{
// Clean up path as needed. Fix slashes and convert to absolute path.
FString NormPath = CurrentPath;
FPaths::NormalizeFilename(NormPath);
FPaths::RemoveDuplicateSlashes(NormPath);
FString AbsPath = FPaths::ConvertRelativePathToFull(NormPath);
TCHAR Temp[MAX_PATH_LENGTH];
DirectoryNodesArray.Empty();
FString BuiltPath;
if (PLATFORM_WINDOWS)
{
int32 Idx;
if (AbsPath.FindChar(TCHAR('/'), Idx))
{
BuiltPath = BuiltPath + TEXT("/") + AbsPath.Left(Idx);
}
FCString::Strncpy(Temp, &AbsPath[Idx < AbsPath.Len() - 1 ? Idx + 1 : Idx], UE_ARRAY_COUNT(Temp));
DirectoryNodesArray.Add(FDirNode(AbsPath.Left(Idx), nullptr));
}
else if (PLATFORM_LINUX)
{
// start with system base directory
FCString::Strncpy(Temp, *AbsPath, UE_ARRAY_COUNT(Temp));
BuiltPath = "/";
DirectoryNodesArray.Add(FDirNode(FString(TEXT("/")), nullptr));
}
else
{
checkf(false, TEXT("SlateDialogs will not work on this platform (modify SSlateFileOpenDlg::BuildDirectoryPath())"));
}
// break path into tokens
TCHAR *ContextStr = nullptr;
TCHAR *DirNode = FCString::Strtok(Temp, TEXT("/"), &ContextStr);
while (DirNode)
{
FString Label = DirNode;
DirectoryNodesArray.Add(FDirNode(Label, nullptr));
BuiltPath = BuiltPath + Label + TEXT("/");
DirNode = FCString::Strtok(nullptr, TEXT("/"), &ContextStr);
}
RefreshCrumbs();
}
void SSlateFileOpenDlg::RefreshCrumbs()
{
// refresh crumb list
if (PathBreadcrumbTrail.IsValid())
{
PathBreadcrumbTrail->ClearCrumbs();
FString BuiltPath;
if (PLATFORM_WINDOWS)
{
PathBreadcrumbTrail->PushCrumb(LOCTEXT("SlateFileDialogsSystem", "System"), FString("SYSTEM"));
for (int32 i = 0; i < DirectoryNodesArray.Num(); i++)
{
BuiltPath = BuiltPath + DirectoryNodesArray[i].Label + TEXT("/");
PathBreadcrumbTrail->PushCrumb(FText::FromString(DirectoryNodesArray[i].Label), BuiltPath);
}
}
else if (PLATFORM_LINUX)
{
BuiltPath = "/";
PathBreadcrumbTrail->PushCrumb(FText::FromString(BuiltPath), BuiltPath);
for (int32 i = 1; i < DirectoryNodesArray.Num(); i++)
{
BuiltPath = BuiltPath + DirectoryNodesArray[i].Label + TEXT("/");
PathBreadcrumbTrail->PushCrumb(FText::FromString(DirectoryNodesArray[i].Label), BuiltPath);
}
}
}
}
void SSlateFileOpenDlg::OnPathClicked(const FString& NewPath)
{
if (NewPath.Compare("SYSTEM") == 0)
{
// Ignore clicks on the virtual root. (Only happens for Windows systems.)
return;
}
// set new current path and flag that we need to update directory display
CurrentPath = NewPath;
bRebuildDirPath = true;
bNeedsBuilding = true;
if ((History.Num()-HistoryIndex-1) > 0)
{
History.RemoveAt(HistoryIndex+1, History.Num()-HistoryIndex-1, EAllowShrinking::Yes);
}
History.Add(CurrentPath);
HistoryIndex++;
RefreshCrumbs();
}
void SSlateFileOpenDlg::OnPathMenuItemClicked( FString ClickedPath )
{
CurrentPath = ClickedPath;
bRebuildDirPath = true;
bNeedsBuilding = true;
if ((History.Num()-HistoryIndex-1) > 0)
{
History.RemoveAt(HistoryIndex+1, History.Num()-HistoryIndex-1, EAllowShrinking::Yes);
}
History.Add(CurrentPath);
HistoryIndex++;
RefreshCrumbs();
}
TSharedRef<SWidget> SSlateFileOpenDlg::OnGetCrumbDelimiterContent(const FString& CrumbData) const
{
TSharedPtr<SWidget> Widget = SNullWidget::NullWidget;
TArray<FString> SubDirs;
IFileManager& FileManager = IFileManager::Get();
FSlateFileDialogDirVisitor DirVisitor(&SubDirs);
if (PLATFORM_WINDOWS)
{
if (CrumbData.Compare("SYSTEM") == 0)
{
// Windows doesn't have a root file system. So we need to provide a way to select system drives.
// This is done by creating a virtual root using 'System' as the top node.
int32 DrivesMask =
#if PLATFORM_WINDOWS
(int32)GetLogicalDrives()
#else
0
#endif // PLATFORM_WINDOWS
;
FMenuBuilder MenuBuilder(true, NULL);
const TCHAR *DriveLetters = TEXT("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
FString Drive = TEXT("A:");
for (int32 i = 0; i < 26; i++)
{
if (DrivesMask & 0x01)
{
Drive[0] = DriveLetters[i];
MenuBuilder.AddMenuEntry(
FText::FromString(Drive),
FText::GetEmpty(),
FSlateIcon(),
FUIAction(FExecuteAction::CreateSP(const_cast<SSlateFileOpenDlg*>(this), &SSlateFileOpenDlg::OnPathMenuItemClicked, Drive + TEXT("/"))));
}
DrivesMask >>= 1;
}
return SNew(SVerticalBox)
+ SVerticalBox::Slot()
.MaxHeight(400.0f)
[
MenuBuilder.MakeWidget()
];
}
}
FileManager.IterateDirectory(*CrumbData, DirVisitor);
if (SubDirs.Num() > 0)
{
SubDirs.Sort();
FMenuBuilder MenuBuilder( true, NULL );
for (int32 i = 0; i < SubDirs.Num(); i++)
{
const FString& SubDir = SubDirs[i];
MenuBuilder.AddMenuEntry(
FText::FromString(SubDir),
FText::GetEmpty(),
FSlateIcon(),
FUIAction(FExecuteAction::CreateSP(const_cast<SSlateFileOpenDlg*>(this), &SSlateFileOpenDlg::OnPathMenuItemClicked, CrumbData + SubDir + TEXT("/"))));
}
Widget =
SNew( SVerticalBox )
+SVerticalBox::Slot()
.MaxHeight(400.0f)
[
MenuBuilder.MakeWidget()
];
}
return Widget.ToSharedRef();
}
FReply SSlateFileOpenDlg::OnQuickLinkClick(FSlateFileDlgWindow::EResult ButtonID)
{
if (ButtonID == FSlateFileDlgWindow::Project)
{
// Taken from DesktopPlatform. We have to do this to avoid a circular dependency.
const FString DefaultProjectSubFolder =TEXT("Unreal Projects");
CurrentPath = FPaths::ConvertRelativePathToFull(FString(FPlatformProcess::UserDir()) + DefaultProjectSubFolder + TEXT("/"));
}
if (ButtonID == FSlateFileDlgWindow::Engine)
{
CurrentPath = FPaths::ConvertRelativePathToFull(FPaths::EngineDir());
}
if ((History.Num()-HistoryIndex-1) > 0)
{
History.RemoveAt(HistoryIndex+1, History.Num()-HistoryIndex-1, EAllowShrinking::Yes);
}
History.Add(CurrentPath);
HistoryIndex++;
bNeedsBuilding = true;
bRebuildDirPath = true;
return FReply::Handled();
}
void SSlateFileOpenDlg::SetOutputFiles()
{
if (OutNames != nullptr)
{
TArray<FString> NamesArray;
ParseTextField(NamesArray, SaveFilename);
OutNames->Empty();
if (bDirectoriesOnly)
{
if (NamesArray.Num() > 0)
{
FString Path = CurrentPath + NamesArray[0];
OutNames->Add(Path);
}
else
{
// select the current directory
OutNames->Add(CurrentPath);
}
}
else
{
for (int32 i=0; i < NamesArray.Num(); i++)
{
FString Path = CurrentPath + NamesArray[i];
OutNames->Add(Path);
}
if (OutFilterIndex != nullptr)
{
*(OutFilterIndex) = FilterIndex;
}
}
}
}
TSharedPtr<FFileEntry> SSlateFileOpenDlg::GetSoloDirectorySelected() const
{
TArray<TSharedPtr<FFileEntry>> SelectedItems = ListView->GetSelectedItems();
if (SelectedItems.Num() == 1 && SelectedItems[0]->bIsDirectory)
{
return SelectedItems[0];
}
return nullptr;
}
bool SSlateFileOpenDlg::IsAcceptEnabled() const
{
if (bDirectoriesOnly)
{
return true;
}
TSharedPtr<FFileEntry> SoloSelectedDirectory = GetSoloDirectorySelected();
if (SoloSelectedDirectory.IsValid())
{
return true;
}
else if (!SaveFilename.IsEmpty())
{
return true;
}
return false;
}
FReply SSlateFileOpenDlg::OnAcceptCancelClick(FSlateFileDlgWindow::EResult ButtonID)
{
if (ButtonID == FSlateFileDlgWindow::Accept)
{
if (!bDirectoriesOnly)
{
TSharedPtr<FFileEntry> SoloSelectedDirectory = GetSoloDirectorySelected();
if (SoloSelectedDirectory.IsValid())
{
OnItemDoubleClicked(SoloSelectedDirectory);
return FReply::Handled();
}
}
SetOutputFiles();
}
else
{
if (OutNames != nullptr)
{
OutNames->Empty();
}
}
UserResponse = ButtonID;
ParentWindow.Pin()->RequestDestroyWindow();
return FReply::Handled();
}
FReply SSlateFileOpenDlg::OnDirSublevelClick(int32 Level)
{
DirectoryNodesArray[DirNodeIndex].TextBlock->SetFont(StyleSet->GetFontStyle("SlateFileDialogs.Dialog"));
FString NewPath = TEXT("/");
for (int32 i = 1; i <= Level; i++)
{
NewPath += DirectoryNodesArray[i].Label + TEXT("/");
}
CurrentPath = NewPath;
bRebuildDirPath = false;
bNeedsBuilding = true;
DirNodeIndex = Level;
DirectoryNodesArray[DirNodeIndex].TextBlock->SetFont(StyleSet->GetFontStyle("SlateFileDialogs.DialogBold"));
return FReply::Handled();
}
void SSlateFileOpenDlg::Tick(const FGeometry &AllottedGeometry, const double InCurrentTime, const float InDeltaTime)
{
SCompoundWidget::Tick(AllottedGeometry, InCurrentTime, InDeltaTime);
if (DirectoryWatcher)
{
DirectoryWatcher->Tick(InDeltaTime);
}
if (bDirectoryHasChanged && !bNeedsBuilding)
{
ReadDir(true);
RebuildFileTable();
ListView->RequestListRefresh();
bDirectoryHasChanged = false;
}
if (bNeedsBuilding)
{
// quick-link buttons to directory sublevels
if (bRebuildDirPath)
{
BuildDirectoryPath();
}
// Get directory contents and rebuild list
ParseFilters();
ReadDir();
RebuildFileTable();
ListView->RequestListRefresh();
}
bNeedsBuilding = false;
bRebuildDirPath = false;
}
void SSlateFileOpenDlg::ReadDir(bool bIsRefresh)
{
if (DirectoryWatcher && RegisteredPath.Len() > 0 && !bIsRefresh)
{
DirectoryWatcher->UnregisterDirectoryChangedCallback_Handle(RegisteredPath, OnDialogDirectoryChangedDelegateHandle);
RegisteredPath = TEXT("");
}
IFileManager& FileManager = IFileManager::Get();
FilesArray.Empty();
FoldersArray.Empty();
FString FilterList;
if (FilterListArray.Num() > 0 && FilterIndex >= 0)
{
FilterList = FilterListArray[FilterIndex];
}
FSlateFileDialogVisitor DirVisitor(FilesArray, FoldersArray, FilterList);
FileManager.IterateDirectory(*CurrentPath, DirVisitor);
FilesArray.Sort(FFileEntry::ConstPredicate);
FoldersArray.Sort(FFileEntry::ConstPredicate);
if (DirectoryWatcher && !bIsRefresh)
{
DirectoryWatcher->RegisterDirectoryChangedCallback_Handle(CurrentPath,
IDirectoryWatcher::FDirectoryChanged::CreateRaw(this, &SSlateFileOpenDlg::OnDirectoryChanged),
OnDialogDirectoryChangedDelegateHandle, IDirectoryWatcher::WatchOptions::IncludeDirectoryChanges | IDirectoryWatcher::WatchOptions::IgnoreChangesInSubtree);
RegisteredPath = CurrentPath;
}
}
void SSlateFileOpenDlg::OnDirectoryChanged(const TArray <FFileChangeData> &FileChanges)
{
bDirectoryHasChanged = true;
}
void SSlateFileOpenDlg::RebuildFileTable()
{
LineItemArray.Empty();
// directory entries
for (int32 i = 0; i < FoldersArray.Num(); i++)
{
LineItemArray.Add(FoldersArray[i]);
}
// file entries
if (bDirectoriesOnly == false)
{
for (int32 i = 0; i < FilesArray.Num(); i++)
{
LineItemArray.Add(FilesArray[i]);
}
}
}
TSharedRef<ITableRow> SSlateFileOpenDlg::OnGenerateWidgetForList(TSharedPtr<FFileEntry> Item,
const TSharedRef<STableViewBase> &OwnerTable)
{
return SNew(SSlateFileDialogRow, OwnerTable)
.DialogItem(Item)
.StyleSet(StyleSet);
}
void SSlateFileOpenDlg::OnItemDoubleClicked(TSharedPtr<FFileEntry> Item)
{
if (Item->bIsDirectory)
{
if (!bSaveFile)
{
SetDefaultFile(FString(""));
}
CurrentPath = CurrentPath + Item->Label + TEXT("/");
bNeedsBuilding = true;
bRebuildDirPath = true;
if ((History.Num()-HistoryIndex-1) > 0)
{
History.RemoveAt(HistoryIndex+1, History.Num()-HistoryIndex-1, EAllowShrinking::Yes);
}
History.Add(CurrentPath);
HistoryIndex++;
}
else
{
SetOutputFiles();
UserResponse = FSlateFileDlgWindow::Accept;
ParentWindow.Pin()->RequestDestroyWindow();
}
}
void SSlateFileOpenDlg::OnFilterChanged(TSharedPtr<FString> NewValue, ESelectInfo::Type SelectInfo)
{
for (int32 i = 0; i < FilterNameArray.Num(); i++)
{
if (NewValue.IsValid() && FilterNameArray[i].Get()->Compare(*NewValue.Get(), ESearchCase::CaseSensitive) == 0)
{
FilterIndex = i;
break;
}
}
bNeedsBuilding = true;
}
void SSlateFileOpenDlg::ParseTextField(TArray<FString> &FilenameArray, FString Files)
{
FString FileList = Files;
FileList.TrimStartAndEndInline();
FilenameArray.Empty();
if (FileList.Len() > 0 && FileList[0] == TCHAR('"'))
{
FString TempName;
SaveFilename.Empty();
for (int32 i = 0; i < FileList.Len(); )
{
// find opening quote (")
for (; i < FileList.Len() && FileList[i] != TCHAR('"'); i++);
if (i >= FileList.Len())
{
break;
}
// copy name until closing quote is found.
TempName.Empty();
for (i++; i < FileList.Len() && FileList[i] != TCHAR('"'); i++)
{
TempName.AppendChar(FileList[i]);
}
if (i >= FileList.Len())
{
break;
}
// check to see if file exists or if we're trying to save a file. if so, add it to list.
if (FPaths::FileExists(CurrentPath + TempName) || bSaveFile)
{
FilenameArray.Add(TempName);
}
// if multiselect is off, don't bother parsing out any additional file names.
if (!bMultiSelectEnabled)
{
break;
}
i++;
}
}
else
{
TArray<FString> Extensions;
FString FirstNonWilcardExtension;
// get current filter extension
if (!bDirectoriesOnly && GetFilterExtensions(Extensions))
{
bool bSaveFilenameHasExtension = false;
for ( const FString& Extension : Extensions )
{
bSaveFilenameHasExtension = ( !IsWildcardExtension(Extension) && SaveFilename.EndsWith(Extension, ESearchCase::CaseSensitive) );
if ( !IsWildcardExtension(Extension) && FirstNonWilcardExtension.IsEmpty() )
{
FirstNonWilcardExtension = Extension;
}
if ( bSaveFilenameHasExtension )
{
break;
}
}
// append extension to filename if user left it off
if (!bSaveFilenameHasExtension && !FirstNonWilcardExtension.IsEmpty())
{
Files = Files + FirstNonWilcardExtension;
}
}
FilenameArray.Add(Files);
}
}
void SSlateFileOpenDlg::SetDefaultFile(FString DefaultFile)
{
FString FileList = DefaultFile;
FileList.TrimStartAndEndInline();
if (FileList.Len() > 0 && FileList[0] == TCHAR('"'))
{
TArray<FString> NamesArray;
ParseTextField(NamesArray, FileList);
SaveFilename.Empty();
for (int32 i = 0; i < NamesArray.Num(); i++)
{
SaveFilename = SaveFilename + TEXT("\"") + NamesArray[i] + TEXT("\" ");
// if multiselect is off, don't bother adding any additional file names.
if (!bMultiSelectEnabled)
{
break;
}
}
}
else
{
SaveFilename = FileList;
}
SaveFilenameEditBox->SetText(SaveFilename);
}
void SSlateFileOpenDlg::OnFileNameCommitted(const FText& InText, ETextCommit::Type InCommitType)
{
// update edit box unless user choose to escape out
if (InCommitType != ETextCommit::OnCleared)
{
SaveFilename = InText.ToString();
ListView->ClearSelection();
SetDefaultFile(SaveFilename);
}
}
void SSlateFileOpenDlg::OnItemSelected(TSharedPtr<FFileEntry> Item, ESelectInfo::Type SelectInfo)
{
if (Item.IsValid())
{
FString FileList;
if (!bDirectoriesOnly)
{
TArray<TSharedPtr<FFileEntry>> SelectedItems = ListView->GetSelectedItems();
for (int32 i = 0; i < SelectedItems.Num(); i++)
{
if (!SelectedItems[i]->bIsDirectory)
{
FileList = FileList + TEXT("\"") + SelectedItems[i]->Label + TEXT("\" ");
}
}
}
else
{
FileList = Item->Label;
}
// Update file name text as long as we aren't saving a file with a directory selected
if (!(bSaveFile && Item->bIsDirectory))
{
SetDefaultFile(FileList);
}
}
}
void SSlateFileOpenDlg::ParseFilters()
{
if (FilterCombo.IsValid() && FilterHBox.IsValid())
{
if (Filters.Len() > 0)
{
if (FilterNameArray.Num() == 0)
{
TCHAR Temp[MAX_FILTER_LENGTH] = {0};
FCString::Strncpy(Temp, *Filters, UE_ARRAY_COUNT(Temp));
// break path into tokens
TCHAR *ContextStr = nullptr;
TCHAR *FilterDescription = FCString::Strtok(Temp, TEXT("|"), &ContextStr);
TCHAR *FilterList;
while (FilterDescription)
{
// filter wild cards
FilterList = FCString::Strtok(nullptr, TEXT("|"), &ContextStr);
FilterNameArray.Add(MakeShareable(new FString(FilterDescription)));
FilterListArray.Add(FString(FilterList));
// next filter entry
FilterDescription = FCString::Strtok(nullptr, TEXT("|"), &ContextStr);
}
}
FilterComboBoxTitleBlock->SetText(FText::FromString(*FilterNameArray[FilterIndex]));
}
else
{
FilterNameArray.Empty();
FilterHBox->SetVisibility(EVisibility::Hidden);
}
}
}
bool SSlateFileOpenDlg::GetFilterExtensions(TArray<FString>& OutExtensions)
{
OutExtensions.Reset();
// check to see if filters were given
if (Filters.Len() == 0)
{
return false;
}
// We have attempted to get the filter extension before parsing them
if (FilterListArray.Num() == 0)
{
ParseFilters();
}
if (!FilterListArray.IsValidIndex(FilterIndex))
{
return false;
}
TArray<FString> Extensions;
const bool bCullEmpty = true;
if (FilterListArray[FilterIndex].ParseIntoArray(Extensions, TEXT(";"), bCullEmpty) > 0)
{
for (FString& Extension : Extensions)
{
// find start of extension
int32 DotIndex;
if (Extension.FindChar(TEXT('.'), DotIndex))
{
Extension.RightChopInline(DotIndex);
// strip any trailing junk
for (TCHAR& ExtensionChar : Extension)
{
if (ExtensionChar == TEXT(' ') || ExtensionChar == TEXT(')') || ExtensionChar == TEXT(';'))
{
ExtensionChar = 0;
break;
}
}
Extension.TrimToNullTerminator();
// store result and clean up
OutExtensions.Add(Extension);
}
else if (Extension[0] == TEXT('*'))
{
OutExtensions.Add(Extension);
}
}
}
return OutExtensions.Num() > 0;
}
bool SSlateFileOpenDlg::IsWildcardExtension(const FString& Extension)
{
return (Extension.Find(TEXT(".*")) >= 0) ||
(Extension.Find(TEXT("*")) >= 0);
}
void SSlateFileOpenDlg::OnNewDirectoryCommitted(const FText & InText, ETextCommit::Type InCommitType)
{
if (InCommitType == ETextCommit::OnEnter)
{
OnNewDirectoryAcceptCancelClick(FSlateFileDlgWindow::Accept);
}
else
{
OnNewDirectoryAcceptCancelClick(FSlateFileDlgWindow::Cancel);
}
}
FReply SSlateFileOpenDlg::OnNewDirectoryClick()
{
NewDirectorySizeBox->SetVisibility(EVisibility::Visible);
NewDirCancelButton->SetVisibility(EVisibility::Visible);
NewDirectoryEditBox->SetText(FString(""));
FSlateApplication::Get().SetKeyboardFocus(NewDirectoryEditBox);
NewDirectoryEditBox->EnterEditingMode();
DirErrorMsg->SetVisibility(EVisibility::Collapsed);
return FReply::Handled().SetUserFocus(NewDirectoryEditBox.ToSharedRef(), EFocusCause::SetDirectly);
}
bool SSlateFileOpenDlg::OnNewDirectoryTextChanged(const FText &InText, FText &ErrorMsg)
{
NewDirectoryName = InText.ToString();
return true;
}
FReply SSlateFileOpenDlg::OnNewDirectoryAcceptCancelClick(FSlateFileDlgWindow::EResult ButtonID)
{
if (ButtonID == FSlateFileDlgWindow::Accept)
{
NewDirectoryName.TrimStartAndEndInline();
if (NewDirectoryName.Len() > 0)
{
IPlatformFile &PlatformFile = FPlatformFileManager::Get().GetPlatformFile();
FString DirPath = CurrentPath + NewDirectoryName;
if (!PlatformFile.CreateDirectory(*DirPath))
{
DirErrorMsg->SetVisibility(EVisibility::Visible);
return FReply::Handled();
}
bDirectoryHasChanged = true;
}
}
NewDirectorySizeBox->SetVisibility(EVisibility::Hidden);
NewDirCancelButton->SetVisibility(EVisibility::Hidden);
DirErrorMsg->SetVisibility(EVisibility::Collapsed);
NewDirectoryEditBox->SetText(FString(""));
return FReply::Handled();
}
FReply SSlateFileOpenDlg::OnGoForwardClick()
{
if ((HistoryIndex+1) < History.Num())
{
if (!bSaveFile)
{
SetDefaultFile(FString(""));
}
HistoryIndex++;
CurrentPath = History[HistoryIndex];
bNeedsBuilding = true;
bRebuildDirPath = true;
bDirectoryHasChanged = false;
}
return FReply::Handled();
}
FReply SSlateFileOpenDlg::OnGoBackClick()
{
if (HistoryIndex > 0)
{
if (!bSaveFile)
{
SetDefaultFile(FString(""));
}
HistoryIndex--;
CurrentPath = History[HistoryIndex];
bNeedsBuilding = true;
bRebuildDirPath = true;
bDirectoryHasChanged = false;
}
return FReply::Handled();
}
#undef LOCTEXT_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink