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

1317 lines
41 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "SProjectBrowser.h"
#include "AnalyticsEventAttribute.h"
#include "Brushes/SlateDynamicImageBrush.h"
#include "Containers/EnumAsByte.h"
#include "Containers/Map.h"
#include "CoreGlobals.h"
#include "DesktopPlatformModule.h"
#include "EditorDirectories.h"
#include "EngineAnalytics.h"
#include "Fonts/SlateFontInfo.h"
#include "Framework/Commands/UIAction.h"
#include "Framework/Commands/UICommandInfo.h"
#include "Framework/MultiBox/MultiBoxBuilder.h"
#include "Framework/Views/ITypedTableView.h"
#include "GameProjectUtils.h"
#include "GenericPlatform/GenericWindow.h"
#include "HAL/FileManager.h"
#include "HAL/PlatformMisc.h"
#include "HAL/PlatformProcess.h"
#include "IAnalyticsProviderET.h"
#include "IDesktopPlatform.h"
#include "ILauncherPlatform.h"
#include "Input/Events.h"
#include "InputCoreTypes.h"
#include "Interfaces/IMainFrameModule.h"
#include "Interfaces/IProjectManager.h"
#include "Internationalization/BreakIterator.h"
#include "Internationalization/Internationalization.h"
#include "LauncherPlatformModule.h"
#include "Layout/Children.h"
#include "Layout/Margin.h"
#include "Logging/LogCategory.h"
#include "Logging/LogMacros.h"
#include "Math/Vector2D.h"
#include "Math/Vector4.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Attribute.h"
#include "Misc/DataDrivenPlatformInfoRegistry.h"
#include "Misc/DateTime.h"
#include "Misc/EngineVersion.h"
#include "Misc/EngineVersionBase.h"
#include "Misc/FeedbackContext.h"
#include "Misc/MessageDialog.h"
#include "Misc/OutputDeviceRedirector.h"
#include "Misc/Paths.h"
#include "Misc/UProjectInfo.h"
#include "Modules/ModuleManager.h"
#include "PlatformInfo.h"
#include "ProjectDescriptor.h"
#include "SSimpleButton.h"
#include "SVerbChoiceDialog.h"
#include "Settings/EditorSettings.h"
#include "SlotBase.h"
#include "SourceCodeNavigation.h"
#include "Styling/AppStyle.h"
#include "Styling/ISlateStyle.h"
#include "Styling/SlateBrush.h"
#include "Styling/SlateColor.h"
#include "Styling/SlateTypes.h"
#include "Styling/StyleColors.h"
#include "Styling/StyleDefaults.h"
#include "Textures/SlateIcon.h"
#include "Trace/Detail/Channel.h"
#include "Types/SlateStructs.h"
#include "UObject/Class.h"
#include "UObject/NameTypes.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/UnrealNames.h"
#include "UObject/UnrealType.h"
#include "Widgets/Images/SImage.h"
#include "Widgets/Input/SComboButton.h"
#include "Widgets/Input/SSearchBox.h"
#include "Widgets/Layout/SBorder.h"
#include "Widgets/Layout/SBox.h"
#include "Widgets/SBoxPanel.h"
#include "Widgets/SOverlay.h"
#include "Widgets/SToolTip.h"
#include "Widgets/SWindow.h"
#include "Widgets/Text/STextBlock.h"
#include "Widgets/Views/STableRow.h"
#include "Widgets/Views/STableViewBase.h"
#include "Widgets/Views/STileView.h"
class SWidget;
struct FGeometry;
#define LOCTEXT_NAMESPACE "ProjectBrowser"
DEFINE_LOG_CATEGORY_STATIC(LogProjectBrowser, Log, All);
namespace ProjectBrowserDefs
{
constexpr float ProjectTileHeight = 153;
constexpr float ProjectTileWidth = 102;
constexpr float ThumbnailSize = 64.0f, ThumbnailPadding = 5.f;
}
/**
* Structure for project items.
*/
struct FProjectItem
{
FText Name;
FText Description;
FText Category;
FString EngineIdentifier;
FEngineVersion ProjectVersion;
FString ProjectFile;
TArray<FName> TargetPlatforms;
TSharedPtr<FSlateBrush> ProjectThumbnail;
FDateTime LastAccessTime;
bool bUpToDate;
bool bSupportsAllPlatforms;
FProjectItem(const FText& InName, const FText& InDescription, const FString& InEngineIdentifier, bool InUpToDate, const TSharedPtr<FSlateBrush>& InProjectThumbnail, const FString& InProjectFile, TArray<FName> InTargetPlatforms, bool InSupportsAllPlatforms)
: Name(InName)
, Description(InDescription)
, Category()
, EngineIdentifier(InEngineIdentifier)
, ProjectFile(InProjectFile)
, TargetPlatforms(InTargetPlatforms)
, ProjectThumbnail(InProjectThumbnail)
, bUpToDate(InUpToDate)
, bSupportsAllPlatforms(InSupportsAllPlatforms)
{
if(bUpToDate)
{
ProjectVersion = FEngineVersion::Current();
}
else if (FDesktopPlatformModule::Get()->IsStockEngineRelease(EngineIdentifier))
{
FDesktopPlatformModule::Get()->TryParseStockEngineVersion(EngineIdentifier, ProjectVersion);
}
if (ProjectVersion.IsEmpty())
{
FString RootDir;
FDesktopPlatformModule::Get()->GetEngineRootDirFromIdentifier(EngineIdentifier, RootDir);
FDesktopPlatformModule::Get()->TryGetEngineVersion(RootDir, ProjectVersion);
}
}
/** Check if this project is up to date */
bool IsUpToDate() const
{
return bUpToDate;
}
/** Gets the engine label for this project */
FText GetEngineLabel() const
{
if(bUpToDate)
{
return LOCTEXT("CurrentEngineVersion", "Current");
}
else if(FDesktopPlatformModule::Get()->IsStockEngineRelease(EngineIdentifier))
{
return FText::FromString(EngineIdentifier);
}
else if(!ProjectVersion.IsEmpty())
{
return FText::FromString(ProjectVersion.ToString(EVersionComponent::Patch));
}
else
{
return FText::FromString(TEXT("?"));
}
}
bool CompareEngineVersion(const FProjectItem& Other) const
{
EVersionComponent Component;
return FEngineVersion::GetNewest(ProjectVersion, Other.ProjectVersion, &Component) == EVersionComparison::First ? true : false;
}
};
class SProjectTile : public STableRow<TSharedPtr<FProjectItem>>
{
SLATE_BEGIN_ARGS(SProjectTile)
{}
SLATE_END_ARGS()
public:
void Construct(const FArguments& InArgs, TSharedPtr<FProjectItem> ProjectItem, const TSharedRef<STableViewBase>& OwnerTable)
{
STableRow::Construct(
STableRow::FArguments()
.Style(FAppStyle::Get(), "ProjectBrowser.TableRow")
.Padding(2.0f)
.Content()
[
SNew(SBorder)
.Padding(FMargin(0.0f, 0.0f, 5.0f, 5.0f))
.BorderImage(FAppStyle::Get().GetBrush("ProjectBrowser.ProjectTile.DropShadow"))
[
SNew(SOverlay)
+ SOverlay::Slot()
[
SNew(SVerticalBox)
// Thumbnail
+ SVerticalBox::Slot()
.AutoHeight()
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
[
SNew(SBox)
.WidthOverride(102.0f)
.HeightOverride(102.0f)
[
SNew(SBorder)
.BorderImage(FAppStyle::Get().GetBrush("ProjectBrowser.ProjectTile.ThumbnailAreaBackground"))
.HAlign(HAlign_Fill)
.VAlign(VAlign_Fill)
.Padding(FMargin(0))
[
SNew(SImage)
.Image(ProjectItem->ProjectThumbnail ? ProjectItem->ProjectThumbnail.Get() : FAppStyle::Get().GetBrush("UnrealDefaultThumbnail"))
.ColorAndOpacity(FAppStyle::Get().GetSlateColor("Colors.Foreground"))
]
]
]
// Name
+ SVerticalBox::Slot()
[
SNew(SBorder)
.Padding(FMargin(ProjectBrowserDefs::ThumbnailPadding, 0))
.Padding(FMargin(3.0f, 3.0f))
.BorderImage_Lambda
(
[this]()
{
const bool bIsSelected = IsSelected();
const bool bIsRowHovered = IsHovered();
if (bIsSelected && bIsRowHovered)
{
static const FName SelectedHover("ProjectBrowser.ProjectTile.NameAreaSelectedHoverBackground");
return FAppStyle::Get().GetBrush(SelectedHover);
}
else if (bIsSelected)
{
static const FName Selected("ProjectBrowser.ProjectTile.NameAreaSelectedBackground");
return FAppStyle::Get().GetBrush(Selected);
}
else if (bIsRowHovered)
{
static const FName Hovered("ProjectBrowser.ProjectTile.NameAreaHoverBackground");
return FAppStyle::Get().GetBrush(Hovered);
}
return FAppStyle::Get().GetBrush("ProjectBrowser.ProjectTile.NameAreaBackground");
}
)
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
[
SNew(STextBlock)
.Font(FAppStyle::Get().GetFontStyle("ProjectBrowser.ProjectTile.Font"))
.WrapTextAt(ProjectBrowserDefs::ProjectTileWidth - 4.0f)
.LineBreakPolicy(FBreakIterator::CreateCamelCaseBreakIterator())
.Text(ProjectItem->Name)
.ColorAndOpacity_Lambda
(
[this]()
{
const bool bIsSelected = IsSelected();
const bool bIsRowHovered = IsHovered();
if (bIsSelected || bIsRowHovered)
{
return FStyleColors::White;
}
return FSlateColor::UseForeground();
}
)
]
+SVerticalBox::Slot()
.AutoHeight()
.Padding(0.0f, 4.0f, 0.0f, 0.0f)
.VAlign(VAlign_Bottom)
[
SNew(STextBlock)
.Text(ProjectItem->GetEngineLabel())
.Font(FAppStyle::Get().GetFontStyle("ProjectBrowser.ProjectTile.Font"))
.ColorAndOpacity_Lambda
(
[this]()
{
const bool bIsSelected = IsSelected();
const bool bIsRowHovered = IsHovered();
if (bIsSelected || bIsRowHovered)
{
return FStyleColors::White;
}
return FSlateColor::UseSubduedForeground();
}
)
]
]
]
]
+ SOverlay::Slot()
[
SNew(SImage)
.Visibility(EVisibility::HitTestInvisible)
.Image_Lambda
(
[this]()
{
const bool bIsSelected = IsSelected();
const bool bIsRowHovered = IsHovered();
if (bIsSelected && bIsRowHovered)
{
static const FName SelectedHover("ProjectBrowser.ProjectTile.SelectedHoverBorder");
return FAppStyle::Get().GetBrush(SelectedHover);
}
else if (bIsSelected)
{
static const FName Selected("ProjectBrowser.ProjectTile.SelectedBorder");
return FAppStyle::Get().GetBrush(Selected);
}
else if (bIsRowHovered)
{
static const FName Hovered("ProjectBrowser.ProjectTile.HoverBorder");
return FAppStyle::Get().GetBrush(Hovered);
}
return FStyleDefaults::GetNoBrush();
}
)
]
]
],
OwnerTable);
}
};
void ProjectItemToString(const TSharedPtr<FProjectItem> InItem, TArray<FString>& OutFilterStrings)
{
OutFilterStrings.Add(InItem->Name.ToString());
}
/* SCompoundWidget interface
*****************************************************************************/
SProjectBrowser::SProjectBrowser()
: ProjectItemFilter( ProjectItemTextFilter::FItemToStringArray::CreateStatic( ProjectItemToString ))
, bPreventSelectionChangeEvent(false)
{
}
void SProjectBrowser::Construct( const FArguments& InArgs )
{
// Prepare the projects box
ProjectsBox = SNew(SVerticalBox);
SAssignNew(ProjectTileView, STileView<TSharedPtr<FProjectItem>>)
.ListItemsSource(&FilteredProjectItemsSource)
.SelectionMode(ESelectionMode::Single)
.ClearSelectionOnClick(false)
.ItemAlignment(EListItemAlignment::LeftAligned)
.OnGenerateTile(this, &SProjectBrowser::MakeProjectViewWidget)
.OnContextMenuOpening(this, &SProjectBrowser::OnGetContextMenuContent)
.OnMouseButtonDoubleClick(this, &SProjectBrowser::HandleProjectItemDoubleClick)
.OnSelectionChanged(this, &SProjectBrowser::HandleProjectViewSelectionChanged)
.ItemHeight(ProjectBrowserDefs::ProjectTileHeight+9)
.ItemWidth(ProjectBrowserDefs::ProjectTileWidth+9);
// Find all projects
FindProjects();
ProjectsBox->AddSlot()
.HAlign(HAlign_Center)
.Padding(FMargin(0.f, 25.f))
[
SNew(STextBlock)
.Visibility(this, &SProjectBrowser::GetNoProjectsErrorVisibility)
.Text(LOCTEXT("NoProjects", "You don't have any projects yet :("))
];
ProjectsBox->AddSlot()
.HAlign(HAlign_Center)
.Padding(FMargin(0.f, 25.f))
[
SNew(STextBlock)
.Visibility(this, &SProjectBrowser::GetNoProjectsAfterFilterErrorVisibility)
.Text(LOCTEXT("NoProjectsAfterFilter", "There are no projects that match the specified filter"))
];
ProjectsBox->AddSlot()
[
ProjectTileView.ToSharedRef()
];
FMenuBuilder SortOptionsBuilder(true, nullptr);
auto MakeSortMenuEntry = [this, &SortOptionsBuilder](EProjectSortOption Option, FText Label, FText Tooltip)
{
FUIAction Action;
Action.ExecuteAction = FExecuteAction::CreateSP(this, &SProjectBrowser::SortProjectTiles, Option);
Action.GetActionCheckState = FGetActionCheckState::CreateSP(this, &SProjectBrowser::GetSortOptionCheckState, Option);
SortOptionsBuilder.AddMenuEntry(Label, Tooltip, FSlateIcon(), Action, NAME_None, EUserInterfaceActionType::RadioButton);
};
MakeSortMenuEntry(EProjectSortOption::LastAccessTime, LOCTEXT("ProjectSortMode_LastAcessTime", "Most Recently Used"), FText::GetEmpty());
MakeSortMenuEntry(EProjectSortOption::Alphabetical, LOCTEXT("ProjectSortMode_Alphabetical", "Alphabetical"), FText::GetEmpty());
MakeSortMenuEntry(EProjectSortOption::Version, LOCTEXT("ProjectSortMode_Version", "Version"), FText::GetEmpty());
ChildSlot
[
SNew(SVerticalBox)
+ SVerticalBox::Slot()
.AutoHeight()
[
SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.Padding(FMargin(0, 0, 5.f, 5))
.VAlign(VAlign_Center)
[
SAssignNew(SearchBoxPtr, SSearchBox)
.HintText(LOCTEXT("FilterHint", "Filter Projects..."))
.OnTextChanged(this, &SProjectBrowser::OnFilterTextChanged)
]
+ SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.Padding(FMargin(0, 0, 5.f, 5))
[
SNew(SComboButton)
.ToolTipText(LOCTEXT("SortProjectList", "Sort the project list"))
.ComboButtonStyle(FAppStyle::Get(), "SimpleComboButtonWithIcon")
.MenuContent()
[
SortOptionsBuilder.MakeWidget()
]
.ButtonContent()
[
SNew(SImage)
.Image(FAppStyle::GetBrush("Icons.SortDown"))
.ColorAndOpacity(FSlateColor::UseForeground())
]
]
+SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.Padding(FMargin(0, 0, 5.f, 5))
[
SNew(SSimpleButton)
.OnClicked(this, &SProjectBrowser::FindProjects)
.Icon(FAppStyle::GetBrush("Icons.Refresh"))
.ToolTipText(LOCTEXT("RefreshProjectList", "Refresh the project list"))
]
]
+ SVerticalBox::Slot()
.Padding(FMargin(0, 5.f))
[
ProjectsBox.ToSharedRef()
]
];
ProjectSelectionChangedDelegate = InArgs._OnSelectionChanged;
}
bool SProjectBrowser::HasProjects() const
{
return ProjectItemsSource.Num() > 0;
}
FString SProjectBrowser::GetSelectedProjectFile() const
{
TSharedPtr<FProjectItem> SelectedItem = GetSelectedProjectItem();
if (SelectedItem.IsValid())
{
return SelectedItem->ProjectFile;
}
return FString();
}
/* SProjectBrowser implementation
*****************************************************************************/
TSharedRef<ITableRow> SProjectBrowser::MakeProjectViewWidget(TSharedPtr<FProjectItem> ProjectItem, const TSharedRef<STableViewBase>& OwnerTable)
{
return SNew(SProjectTile, ProjectItem, OwnerTable)
.ToolTip(MakeProjectToolTip(ProjectItem));
}
TSharedRef<SToolTip> SProjectBrowser::MakeProjectToolTip( TSharedPtr<FProjectItem> ProjectItem ) const
{
// Create a box to hold every line of info in the body of the tooltip
TSharedRef<SVerticalBox> InfoBox = SNew(SVerticalBox);
if(!ProjectItem->Description.IsEmpty())
{
AddToToolTipInfoBox( InfoBox, LOCTEXT("ProjectTileTooltipDescription", "Description"), ProjectItem->Description );
}
{
const FString ProjectPath = FPaths::GetPath(ProjectItem->ProjectFile);
AddToToolTipInfoBox( InfoBox, LOCTEXT("ProjectTileTooltipPath", "Path"), FText::FromString(ProjectPath) );
}
{
FText Description;
if(FDesktopPlatformModule::Get()->IsStockEngineRelease(ProjectItem->EngineIdentifier))
{
Description = FText::FromString(ProjectItem->EngineIdentifier);
}
else
{
FString RootDir;
if(FDesktopPlatformModule::Get()->GetEngineRootDirFromIdentifier(ProjectItem->EngineIdentifier, RootDir))
{
FString PlatformRootDir = RootDir;
FPaths::MakePlatformFilename(PlatformRootDir);
Description = FText::FromString(PlatformRootDir);
}
else
{
Description = LOCTEXT("UnknownEngineVersion", "Unknown engine version");
}
}
AddToToolTipInfoBox(InfoBox, LOCTEXT("EngineVersion", "Engine"), Description);
}
// Create the target platform icons
TSharedRef<SHorizontalBox> TargetPlatformIconsBox = SNew(SHorizontalBox);
for(const FName& PlatformName : ProjectItem->TargetPlatforms)
{
const PlatformInfo::FTargetPlatformInfo* const PlatformInfo = PlatformInfo::FindPlatformInfo(PlatformName);
check(PlatformInfo);
TargetPlatformIconsBox->AddSlot()
.AutoWidth()
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.Padding(FMargin(0.0f, 0.0f, 1.0f, 0.0f))
[
SNew(SBox)
.WidthOverride(20.0f)
.HeightOverride(20.0f)
[
SNew(SImage)
.Image(FAppStyle::GetBrush(PlatformInfo->GetIconStyleName(EPlatformIconSize::Normal)))
]
];
}
TSharedRef<SToolTip> Tooltip = SNew(SToolTip)
.TextMargin(1.0f)
.BorderImage( FAppStyle::GetBrush("ProjectBrowser.TileViewTooltip.ToolTipBorder") )
[
SNew(SBorder)
.Padding(6.0f)
.BorderImage( FAppStyle::GetBrush("ProjectBrowser.TileViewTooltip.NonContentBorder") )
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
.AutoHeight()
.Padding(0.0f, 0.0f, 0.0f, 4.0f)
[
SNew(SBorder)
.Padding(6.0f)
.BorderImage( FAppStyle::GetBrush("ProjectBrowser.TileViewTooltip.ContentBorder") )
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
.AutoHeight()
.VAlign(VAlign_Center)
[
SNew(STextBlock)
.Text( ProjectItem->Name )
.Font( FAppStyle::GetFontStyle("ProjectBrowser.TileViewTooltip.NameFont") )
]
+SVerticalBox::Slot()
.AutoHeight()
.VAlign(VAlign_Center)
.Padding(0.0f, 2.0f, 0.0f, 0.0f)
[
TargetPlatformIconsBox
]
]
]
+SVerticalBox::Slot()
.AutoHeight()
[
SNew(SBorder)
.Padding(6.0f)
.BorderImage( FAppStyle::GetBrush("ProjectBrowser.TileViewTooltip.ContentBorder") )
[
InfoBox
]
]
]
];
return Tooltip;
}
void SProjectBrowser::AddToToolTipInfoBox(const TSharedRef<SVerticalBox>& InfoBox, const FText& Key, const FText& Value) const
{
InfoBox->AddSlot()
.AutoHeight()
.Padding(0.0f, 1.0f)
[
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.AutoWidth()
.Padding(0.0f, 0.0f, 4.0f, 0.0f)
[
SNew(STextBlock) .Text( FText::Format(LOCTEXT("ProjectBrowserTooltipFormat", "{0}:"), Key ) )
.ColorAndOpacity(FSlateColor::UseSubduedForeground())
]
+SHorizontalBox::Slot()
.AutoWidth()
[
SNew(STextBlock) .Text( Value )
.ColorAndOpacity(FSlateColor::UseForeground())
]
];
}
TSharedPtr<SWidget> SProjectBrowser::OnGetContextMenuContent() const
{
FMenuBuilder MenuBuilder(/*bInShouldCloseWindowAfterMenuSelection=*/true, nullptr);
TSharedPtr<FProjectItem> SelectedProjectItem = GetSelectedProjectItem();
const FText ProjectContextActionsText = (SelectedProjectItem.IsValid()) ? SelectedProjectItem->Name : LOCTEXT("ProjectActionsMenuHeading", "Project Actions");
MenuBuilder.BeginSection("ProjectContextActions", ProjectContextActionsText);
FFormatNamedArguments Args;
Args.Add(TEXT("FileManagerName"), FPlatformMisc::GetFileManagerName());
const FText ExploreToText = FText::Format(NSLOCTEXT("GenericPlatform", "ShowInFileManager", "Show in {FileManagerName}"), Args);
MenuBuilder.AddMenuEntry(
ExploreToText,
LOCTEXT("FindInExplorerTooltip", "Finds this project on disk"),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP( this, &SProjectBrowser::ExecuteFindInExplorer ),
FCanExecuteAction::CreateSP( this, &SProjectBrowser::CanExecuteFindInExplorer )
)
);
MenuBuilder.EndSection();
return MenuBuilder.MakeWidget();
}
void SProjectBrowser::ExecuteFindInExplorer() const
{
TSharedPtr<FProjectItem> SelectedProjectItem = GetSelectedProjectItem();
check(SelectedProjectItem.IsValid());
FPlatformProcess::ExploreFolder(*SelectedProjectItem->ProjectFile);
}
bool SProjectBrowser::CanExecuteFindInExplorer() const
{
TSharedPtr<FProjectItem> SelectedProjectItem = GetSelectedProjectItem();
return SelectedProjectItem.IsValid();
}
TSharedPtr<FProjectItem> SProjectBrowser::GetSelectedProjectItem() const
{
TArray< TSharedPtr<FProjectItem> > SelectedItems = ProjectTileView->GetSelectedItems();
if (SelectedItems.Num() > 0)
{
return SelectedItems[0];
}
return nullptr;
}
FText SProjectBrowser::GetSelectedProjectName() const
{
TSharedPtr<FProjectItem> SelectedItem = GetSelectedProjectItem();
if ( SelectedItem.IsValid() )
{
return SelectedItem->Name;
}
return FText::GetEmpty();
}
static TSharedPtr<FSlateDynamicImageBrush> GetThumbnailForProject(const FString& ProjectFilename)
{
TSharedPtr<FSlateDynamicImageBrush> DynamicBrush;
const FString ThumbnailPNGFile = FPaths::GetBaseFilename(ProjectFilename, false) + TEXT(".png");
const FString AutoScreenShotPNGFile = FPaths::Combine(*FPaths::GetPath(ProjectFilename), TEXT("Saved"), TEXT("AutoScreenshot.png"));
FString PNGFileToUse;
if (FPaths::FileExists(ThumbnailPNGFile))
{
PNGFileToUse = ThumbnailPNGFile;
}
else if (FPaths::FileExists(AutoScreenShotPNGFile))
{
PNGFileToUse = AutoScreenShotPNGFile;
}
if (!PNGFileToUse.IsEmpty())
{
const FName BrushName = FName(*PNGFileToUse);
DynamicBrush = MakeShared<FSlateDynamicImageBrush>(BrushName, FVector2D(128, 128));
DynamicBrush->OutlineSettings.CornerRadii = FVector4(4, 4, 0, 0);
DynamicBrush->OutlineSettings.RoundingType = ESlateBrushRoundingType::FixedRadius;
DynamicBrush->DrawAs = ESlateBrushDrawType::RoundedBox;
}
return DynamicBrush;
}
static TSharedPtr<FProjectItem> CreateProjectItem(const FString& ProjectFilename)
{
if (FPaths::FileExists(ProjectFilename))
{
FProjectStatus ProjectStatus;
if (IProjectManager::Get().QueryStatusForProject(ProjectFilename, ProjectStatus))
{
// @todo localized project name
const FText ProjectName = FText::FromString(ProjectStatus.Name);
const FText ProjectDescription = FText::FromString(ProjectStatus.Description);
TSharedPtr<FSlateDynamicImageBrush> DynamicBrush = GetThumbnailForProject(ProjectFilename);
const FString EngineIdentifier = FDesktopPlatformModule::Get()->GetCurrentEngineIdentifier();
FString ProjectEngineIdentifier;
bool bIsUpToDate = FDesktopPlatformModule::Get()->GetEngineIdentifierForProject(ProjectFilename, ProjectEngineIdentifier)
&& ProjectEngineIdentifier == EngineIdentifier;
// Work out which platforms this project is targeting
TArray<FName> TargetPlatforms;
for (const PlatformInfo::FTargetPlatformInfo* PlatformInfo : PlatformInfo::GetVanillaPlatformInfoArray())
{
if (ProjectStatus.IsTargetPlatformSupported(PlatformInfo->Name))
{
TargetPlatforms.Add(PlatformInfo->Name);
}
}
TargetPlatforms.Sort(FNameLexicalLess());
TSharedPtr<FProjectItem> ProjectItem = MakeShareable(new FProjectItem(FText::FromString(ProjectStatus.Name),
FText::FromString(ProjectStatus.Description),
ProjectEngineIdentifier, bIsUpToDate, DynamicBrush, ProjectFilename,
TargetPlatforms, ProjectStatus.SupportsAllPlatforms()));
const FText SamplesCategoryName = LOCTEXT("SamplesCategoryName", "Samples");
if (ProjectStatus.bSignedSampleProject)
{
// Signed samples can't override their category name
ProjectItem->Category = SamplesCategoryName;
}
ProjectItem->LastAccessTime = IFileManager::Get().GetAccessTimeStamp(*ProjectFilename);
return ProjectItem;
}
}
return nullptr;
}
FReply SProjectBrowser::FindProjects()
{
const FString LastSelectedProjectFile = CurrentSelectedProjectPath;
ProjectItemsSource.Empty();
FilteredProjectItemsSource.Empty();
ProjectTileView->RequestListRefresh();
TArray<FRecentProjectFile> RecentProjects = GetDefault<UEditorSettings>()->RecentlyOpenedProjectFiles;
TSet<FString> AllFoundProjectFiles;
// Find all the engine installations
TMap<FString, FString> EngineInstallations;
FDesktopPlatformModule::Get()->EnumerateEngineInstallations(EngineInstallations);
UE_LOG(LogProjectBrowser, Log, TEXT("Looking for projects..."));
// Add projects from every branch that we know about
for (TMap<FString, FString>::TConstIterator Iter(EngineInstallations); Iter; ++Iter)
{
TArray<FString> ProjectFiles;
UE_LOG(LogProjectBrowser, Log, TEXT("Found Engine Installation \"%s\"(%s)"), *Iter.Key(), *Iter.Value());
if (FDesktopPlatformModule::Get()->EnumerateProjectsKnownByEngine(Iter.Key(), false, ProjectFiles))
{
AllFoundProjectFiles.Append(MoveTemp(ProjectFiles));
}
}
// Add all the samples from the launcher
TArray<FString> LauncherSampleProjects;
FDesktopPlatformModule::Get()->EnumerateLauncherSampleProjects(LauncherSampleProjects);
UE_LOG(LogProjectBrowser, Log, TEXT("Enumerating Launcher Sample Projects..."));
for (const FString& Str : LauncherSampleProjects)
{
UE_LOG(LogProjectBrowser, Log, TEXT("Found Sample Project:\"%s\""), *Str);
}
AllFoundProjectFiles.Append(MoveTemp(LauncherSampleProjects));
// Add all the native project files we can find
FUProjectDictionary& DefaultProjectDictionary = FUProjectDictionary::GetDefault();
DefaultProjectDictionary.Refresh();
const TArray<FString>& NativeProjectFiles = DefaultProjectDictionary.GetProjectPaths();
for(const FString& ProjectFile : NativeProjectFiles)
{
if (!ProjectFile.Contains(TEXT("/Templates/")) && !ProjectFile.Contains(TEXT("/Programs/")))
{
AllFoundProjectFiles.Add(ProjectFile);
}
}
TSharedPtr<FProjectItem> NewProjectToSelect;
// Normalize all the filenames and make sure there are no duplicates
for (FString& ProjectFile : AllFoundProjectFiles)
{
FString ProjectFilename = IFileManager::Get().ConvertToAbsolutePathForExternalAppForRead(*ProjectFile);
TSharedPtr<FProjectItem> NewProjectItem = CreateProjectItem(ProjectFilename);
if (NewProjectItem)
{
if (NewProjectItem->ProjectFile == LastSelectedProjectFile)
{
NewProjectToSelect = NewProjectItem;
}
// Get a valid last access time. The editor will set this for recent projects and is more accurate than the NTFS access time
if (FRecentProjectFile* RecentProject = RecentProjects.FindByKey(NewProjectItem->ProjectFile))
{
NewProjectItem->LastAccessTime = RecentProject->LastOpenTime;
}
ProjectItemsSource.Add(NewProjectItem);
}
}
SortProjectTiles(CurrentSortOption);
PopulateFilteredProjects();
if (NewProjectToSelect && FilteredProjectItemsSource.Contains(NewProjectToSelect))
{
ProjectTileView->SetSelection(NewProjectToSelect, ESelectInfo::Direct);
}
else if (FilteredProjectItemsSource.Num() > 0)
{
ProjectTileView->SetSelection(FilteredProjectItemsSource[0], ESelectInfo::Direct);
}
return FReply::Handled();
}
void SProjectBrowser::PopulateFilteredProjects()
{
FilteredProjectItemsSource.Empty();
for (TSharedPtr<FProjectItem>& ProjectItem : ProjectItemsSource)
{
if (ProjectItemFilter.PassesFilter(ProjectItem))
{
FilteredProjectItemsSource.Add(ProjectItem);
}
}
ProjectTileView->RequestListRefresh();
}
FReply SProjectBrowser::OnKeyDown( const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent )
{
if (InKeyEvent.GetKey() == EKeys::F5)
{
return FindProjects();
}
return FReply::Unhandled();
}
bool SProjectBrowser::OpenProject( const FString& InProjectFile )
{
FText FailReason;
FString ProjectFile = InProjectFile;
// Get the identifier for the project
FString ProjectIdentifier;
FDesktopPlatformModule::Get()->GetEngineIdentifierForProject(ProjectFile, ProjectIdentifier);
// Abort straight away if the project engine version is newer than the current engine version
FEngineVersion EngineVersion;
if (FDesktopPlatformModule::Get()->TryParseStockEngineVersion(ProjectIdentifier, EngineVersion))
{
if (FEngineVersion::GetNewest(EngineVersion, FEngineVersion::Current(), nullptr) == EVersionComparison::First)
{
FMessageDialog::Open(EAppMsgType::Ok, LOCTEXT("CantLoadNewerProject", "Unable to open this project, as it was made with a newer version of the Unreal Engine."));
return false;
}
}
// Get the identifier for the current engine
FString CurrentIdentifier = FDesktopPlatformModule::Get()->GetCurrentEngineIdentifier();
if(ProjectIdentifier != CurrentIdentifier)
{
// Get the current project status
FProjectStatus ProjectStatus;
if(!IProjectManager::Get().QueryStatusForProject(ProjectFile, ProjectStatus))
{
FMessageDialog::Open(EAppMsgType::Ok, LOCTEXT("CouldNotReadProjectStatus", "Unable to read project status."));
return false;
}
// If it's a code project, verify the user has the needed compiler installed before we continue.
if ( ProjectStatus.bCodeBasedProject )
{
if ( !FSourceCodeNavigation::IsCompilerAvailable() )
{
const FText TitleText = LOCTEXT("CompilerNeeded", "Missing Compiler");
const FText CompilerStillNotInstalled = FText::Format(LOCTEXT("CompilerStillNotInstalledFormatted", "Press OK when you've finished installing {0}."), FSourceCodeNavigation::GetSuggestedSourceCodeIDE());
if ( FSourceCodeNavigation::GetCanDirectlyInstallSourceCodeIDE() )
{
const FText ErrorText = FText::Format(LOCTEXT("WouldYouLikeToDownloadAndInstallCompiler", "To open this project you must first install {0}.\n\nWould you like to download and install it now?"), FSourceCodeNavigation::GetSuggestedSourceCodeIDE());
EAppReturnType::Type InstallCompilerResult = FMessageDialog::Open(EAppMsgType::YesNo, ErrorText, TitleText);
if ( InstallCompilerResult == EAppReturnType::No )
{
return false;
}
GWarn->BeginSlowTask(LOCTEXT("DownloadingInstalling", "Waiting for Installer to complete."), true, true);
TOptional<bool> bWasDownloadASuccess;
FSourceCodeNavigation::DownloadAndInstallSuggestedIDE(FOnIDEInstallerDownloadComplete::CreateLambda([&bWasDownloadASuccess] (bool bSuccessful) {
bWasDownloadASuccess = bSuccessful;
}));
while ( !bWasDownloadASuccess.IsSet() )
{
// User canceled the install.
if ( GWarn->ReceivedUserCancel() )
{
GWarn->EndSlowTask();
return false;
}
GWarn->StatusUpdate(1, 1, LOCTEXT("WaitingForDownload", "Waiting for download to complete..."));
FPlatformProcess::Sleep(0.1f);
}
GWarn->EndSlowTask();
if ( !bWasDownloadASuccess.GetValue() )
{
const FText DownloadFailed = LOCTEXT("DownloadFailed", "Failed to download. Please check your internet connection.");
if ( FMessageDialog::Open(EAppMsgType::OkCancel, DownloadFailed) == EAppReturnType::Cancel )
{
// User canceled, fail.
return false;
}
}
}
else
{
const FText ErrorText = FText::Format(LOCTEXT("WouldYouLikeToInstallCompiler", "To open this project you must first install {0}.\n\nWould you like to install it now?"), FSourceCodeNavigation::GetSuggestedSourceCodeIDE());
EAppReturnType::Type InstallCompilerResult = FMessageDialog::Open(EAppMsgType::YesNo, ErrorText, TitleText);
if ( InstallCompilerResult == EAppReturnType::No )
{
return false;
}
FString DownloadURL = FSourceCodeNavigation::GetSuggestedSourceCodeIDEDownloadURL();
FPlatformProcess::LaunchURL(*DownloadURL, nullptr, nullptr);
}
// Loop until the users cancels or they complete installation.
while ( !FSourceCodeNavigation::IsCompilerAvailable() )
{
EAppReturnType::Type UserInstalledResult = FMessageDialog::Open(EAppMsgType::OkCancel, CompilerStillNotInstalled);
if ( UserInstalledResult == EAppReturnType::Cancel )
{
return false;
}
FSourceCodeNavigation::RefreshCompilerAvailability();
}
}
}
// Hyperlinks for the upgrade dialog
TArray<FText> Hyperlinks;
int32 MoreOptionsHyperlink = Hyperlinks.Add(LOCTEXT("ProjectConvert_MoreOptions", "More Options..."));
// Button labels for the upgrade dialog
TArray<FText> Buttons;
int32 OpenCopyButton = Buttons.Add(LOCTEXT("ProjectConvert_OpenCopy", "Open a copy"));
int32 CancelButton = Buttons.Add(LOCTEXT("ProjectConvert_Cancel", "Cancel"));
int32 OpenExistingButton = -1;
int32 SkipConversionButton = -1;
// Prompt for upgrading. Different message for code and content projects, since the process is a bit trickier for code.
FText DialogText;
if(ProjectStatus.bCodeBasedProject)
{
DialogText = LOCTEXT("ConvertCodeProjectPrompt", "This project was made with a different version of the Unreal Engine. Converting to this version will rebuild your code projects.\n\nNew features and improvements sometimes cause API changes, which may require you to modify your code before it compiles. Content saved with newer versions of the editor will not open in older versions.\n\nWe recommend you open a copy of your project to avoid damaging the original.");
}
else
{
DialogText = LOCTEXT("ConvertContentProjectPrompt", "This project was made with a different version of the Unreal Engine.\n\nOpening it with this version of the editor may prevent it opening with the original editor, and may lose data. We recommend you open a copy to avoid damaging the original.");
}
// Show the dialog, and expand to the advanced dialog if the user selects 'More Options...'
int32 Selection = SVerbChoiceDialog::ShowModal(LOCTEXT("ProjectConversionTitle", "Convert Project"), DialogText, Hyperlinks, Buttons);
if(~Selection == MoreOptionsHyperlink)
{
OpenExistingButton = Buttons.Insert(LOCTEXT("ProjectConvert_ConvertInPlace", "Convert in-place"), 1);
SkipConversionButton = Buttons.Insert(LOCTEXT("ProjectConvert_SkipConversion", "Skip conversion"), 2);
CancelButton += 2;
Selection = SVerbChoiceDialog::ShowModal(LOCTEXT("ProjectConversionTitle", "Convert Project"), DialogText, Buttons);
}
// Handle the selection
if(Selection == CancelButton)
{
return false;
}
if(Selection == OpenCopyButton)
{
FString NewProjectFile;
GameProjectUtils::EProjectDuplicateResult DuplicateResult = GameProjectUtils::DuplicateProjectForUpgrade(ProjectFile, NewProjectFile);
if (DuplicateResult == GameProjectUtils::EProjectDuplicateResult::UserCanceled)
{
return false;
}
else if (DuplicateResult == GameProjectUtils::EProjectDuplicateResult::Failed)
{
FMessageDialog::Open( EAppMsgType::Ok, LOCTEXT("ConvertProjectCopyFailed", "Couldn't copy project. Check you have sufficient hard drive space and write access to the project folder.") );
return false;
}
ProjectFile = NewProjectFile;
}
if(Selection == OpenExistingButton)
{
FString FailPath;
if(!FDesktopPlatformModule::Get()->CleanGameProject(FPaths::GetPath(ProjectFile), FailPath, GWarn))
{
FText FailMessage = FText::Format(LOCTEXT("ConvertProjectCleanFailed", "{0} could not be removed. Try deleting it manually and try again."), FText::FromString(FailPath));
FMessageDialog::Open(EAppMsgType::Ok, FailMessage);
return false;
}
}
if(Selection != SkipConversionButton)
{
// Update the game project to the latest version. This will prompt to check-out as necessary. We don't need to write the engine identifier directly, because it won't use the right .uprojectdirs logic.
if(!GameProjectUtils::UpdateGameProject(ProjectFile, CurrentIdentifier, FailReason))
{
if(FMessageDialog::Open(EAppMsgType::YesNo, LOCTEXT("ProjectUpgradeFailure", "The project file could not be updated to latest version. Attempt to open anyway?")) != EAppReturnType::Yes)
{
return false;
}
}
// If it's a code-based project, generate project files and open visual studio after an upgrade
if(ProjectStatus.bCodeBasedProject)
{
// Try to generate project files
FStringOutputDevice OutputLog;
OutputLog.SetAutoEmitLineTerminator(true);
GLog->AddOutputDevice(&OutputLog);
bool bHaveProjectFiles = FDesktopPlatformModule::Get()->GenerateProjectFiles(FPaths::RootDir(), ProjectFile, GWarn);
GLog->RemoveOutputDevice(&OutputLog);
// Display any errors
if(!bHaveProjectFiles)
{
FFormatNamedArguments Args;
Args.Add( TEXT("LogOutput"), FText::FromString(OutputLog) );
FMessageDialog::Open(EAppMsgType::Ok, FText::Format(LOCTEXT("CouldNotGenerateProjectFiles", "Project files could not be generated. Log output:\n\n{LogOutput}"), Args));
return false;
}
// Try to compile the project
if(!GameProjectUtils::BuildCodeProject(ProjectFile))
{
return false;
}
}
}
}
// Open the project
if (!GameProjectUtils::OpenProject(ProjectFile, FailReason))
{
FMessageDialog::Open(EAppMsgType::Ok, FailReason);
return false;
}
return true;
}
void SProjectBrowser::OpenSelectedProject( )
{
if (CurrentSelectedProjectPath.IsEmpty())
{
return;
}
OpenProject(CurrentSelectedProjectPath);
}
/* SProjectBrowser event handlers
*****************************************************************************/
FReply SProjectBrowser::OnOpenProject( )
{
OpenSelectedProject();
return FReply::Handled();
}
bool SProjectBrowser::HandleOpenProjectButtonIsEnabled( ) const
{
return !CurrentSelectedProjectPath.IsEmpty();
}
void SProjectBrowser::HandleProjectItemDoubleClick( TSharedPtr<FProjectItem> TemplateItem )
{
OpenSelectedProject();
}
FReply SProjectBrowser::OnBrowseToProject()
{
const FString ProjectFileDescription = LOCTEXT( "FileTypeDescription", "Unreal Project File" ).ToString();
const FString ProjectFileExtension = FString::Printf(TEXT("*.%s"), *FProjectDescriptor::GetExtension());
const FString FileTypes = FString::Printf( TEXT("%s (%s)|%s"), *ProjectFileDescription, *ProjectFileExtension, *ProjectFileExtension );
// Find the first valid project file to select by default
FString DefaultFolder = FEditorDirectories::Get().GetLastDirectory(ELastDirectory::PROJECT);
for (const FRecentProjectFile& RecentFile : GetDefault<UEditorSettings>()->RecentlyOpenedProjectFiles)
{
if ( IFileManager::Get().FileSize(*RecentFile.ProjectName) > 0 )
{
// This is the first uproject file in the recents list that actually exists
DefaultFolder = FPaths::GetPath(*RecentFile.ProjectName);
break;
}
}
// Prompt the user for the filenames
TArray<FString> OpenFilenames;
IDesktopPlatform* DesktopPlatform = FDesktopPlatformModule::Get();
bool bOpened = false;
if ( DesktopPlatform )
{
void* ParentWindowWindowHandle = NULL;
IMainFrameModule& MainFrameModule = FModuleManager::LoadModuleChecked<IMainFrameModule>(TEXT("MainFrame"));
const TSharedPtr<SWindow>& MainFrameParentWindow = MainFrameModule.GetParentWindow();
if ( MainFrameParentWindow.IsValid() && MainFrameParentWindow->GetNativeWindow().IsValid() )
{
ParentWindowWindowHandle = MainFrameParentWindow->GetNativeWindow()->GetOSWindowHandle();
}
bOpened = DesktopPlatform->OpenFileDialog(
ParentWindowWindowHandle,
LOCTEXT("OpenProjectBrowseTitle", "Open Project").ToString(),
DefaultFolder,
TEXT(""),
FileTypes,
EFileDialogFlags::None,
OpenFilenames
);
}
if (bOpened && OpenFilenames.Num() > 0)
{
HandleProjectViewSelectionChanged(nullptr, ESelectInfo::Direct);
FString Path = OpenFilenames[0];
if ( FPaths::IsRelative( Path ) )
{
Path = FPaths::ConvertRelativePathToFull(Path);
}
CurrentSelectedProjectPath = Path;
OpenSelectedProject();
}
return FReply::Handled();
}
void SProjectBrowser::HandleProjectViewSelectionChanged(TSharedPtr<FProjectItem> ProjectItem, ESelectInfo::Type SelectInfo)
{
FString ProjectFile;
if (ProjectItem.IsValid())
{
ProjectFile = ProjectItem->ProjectFile;
CurrentSelectedProjectPath = ProjectFile;
}
else
{
CurrentSelectedProjectPath = FString();
}
ProjectSelectionChangedDelegate.ExecuteIfBound(ProjectFile);
}
void SProjectBrowser::OnFilterTextChanged(const FText& InText)
{
ProjectItemFilter.SetRawFilterText(InText);
SearchBoxPtr->SetError(ProjectItemFilter.GetFilterErrorText());
PopulateFilteredProjects();
}
void SProjectBrowser::OnAutoloadLastProjectChanged(ECheckBoxState NewState)
{
UEditorSettings *Settings = GetMutableDefault<UEditorSettings>();
Settings->bLoadTheMostRecentlyLoadedProjectAtStartup = (NewState == ECheckBoxState::Checked);
FProperty* AutoloadProjectProperty = FindFProperty<FProperty>(Settings->GetClass(), "bLoadTheMostRecentlyLoadedProjectAtStartup");
if (AutoloadProjectProperty != NULL)
{
FPropertyChangedEvent PropertyUpdateStruct(AutoloadProjectProperty);
Settings->PostEditChangeProperty(PropertyUpdateStruct);
}
}
EVisibility SProjectBrowser::GetProjectCategoryVisibility(const TSharedRef<FProjectCategory> InCategory) const
{
return FilteredProjectItemsSource.Num() ? EVisibility::Visible : EVisibility::Collapsed;
}
EVisibility SProjectBrowser::GetNoProjectsErrorVisibility() const
{
return ProjectItemsSource.Num() > 0 ? EVisibility::Collapsed : EVisibility::Visible;
}
EVisibility SProjectBrowser::GetNoProjectsAfterFilterErrorVisibility() const
{
return (ProjectItemsSource.Num() && FilteredProjectItemsSource.Num() == 0) ? EVisibility::Visible : EVisibility::Collapsed;
}
void SProjectBrowser::SortProjectTiles(EProjectSortOption NewSortOption)
{
CurrentSortOption = NewSortOption;
switch (CurrentSortOption)
{
case EProjectSortOption::Version:
ProjectItemsSource.StableSort([](auto& A, auto& B) { return A->CompareEngineVersion(*B); });
break;
case EProjectSortOption::Alphabetical:
ProjectItemsSource.StableSort([](auto& A, auto& B) { return A->Name.CompareTo(B->Name) < 0; });
break;
case EProjectSortOption::LastAccessTime:
default:
ProjectItemsSource.StableSort([](auto& A, auto& B) { return A->LastAccessTime > B->LastAccessTime; });
break;
}
PopulateFilteredProjects();
}
ECheckBoxState SProjectBrowser::GetSortOptionCheckState(EProjectSortOption TestOption) const
{
return CurrentSortOption == TestOption ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
}
FText SProjectBrowser:: GetItemHighlightText() const
{
return ProjectItemFilter.GetRawFilterText();
}
#undef LOCTEXT_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink