izzy/UnrealEngineUWP
0
0
Fork 0
mirror of https://github.com/izzy2lost/UnrealEngineUWP.git synced 2026-03-26 18:15:20 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
c042ddcb9414e3a0a8489be78f8df364d9e5706e
UnrealEngineUWP/Engine/Source/Editor/IntroTutorials/Private/STutorialsBrowser.cpp
Dan Hertzka c042ddcb94 ---- Merging with SlateDev branch ---- 
Introduces the concept of "Active Ticking" to allow Slate to go to sleep when there is no need to update the UI.

While asleep, Slate will skip the Tick & Paint pass for that frame entirely.
- There are TWO ways to "wake" Slate and cause a Tick/Paint pass:
    1. Provide some sort of input (mouse movement, clicks, and key presses). Slate will always tick when the user is active.
        - Therefore, if the logic in a given widget's Tick is only relevant in response to user action, there is no need to register an active tick.
    2. Register an Active Tick. Currently this is an all-or-nothing situation, so if a single active tick needs to execute, all of Slate will be ticked.

- The purpose of an Active Tick is to allow a widget to "drive" Slate and guarantee a Tick/Paint pass in the absence of any user action.
    - Examples include animation, async operations that update periodically, progress updates, loading bars, etc.

- An empty active tick is registered for viewports when they are real-time, so game project widgets are unaffected by this change and should continue to work as before.

- An Active Tick is registered by creating an FWidgetActiveTickDelegate and passing it to SWidget::RegisterActiveTick()
    - There are THREE ways to unregister an active tick:
        1. Return EActiveTickReturnType::StopTicking from the active tick function
        2. Pass the FActiveTickHandle returned by RegisterActiveTick() to SWidget::UnregisterActiveTick()
        3. Destroy the widget responsible for the active tick

- Sleeping is currently disabled, can be enabled with Slate.AllowSlateToSleep cvar
- There is currently a little buffer time during which Slate continues to tick following any input. Long-term, this is planned to be removed.
    - The duration of the buffer can be adjusted using Slate.SleepBufferPostInput cvar (defaults to 1.0f)

- The FCurveSequence API has been updated to work with the active tick system
    - Playing a curve sequence now requires that you pass the widget being animated by the sequence
    - The active tick will automatically be registered on behalf of the widget and unregister when the sequence is complete
    - GetLerpLooping() has been removed. Instead, pass true as the second param to Play() to indicate that the animation will loop. This causes the active tick to be registered indefinitely until paused or jumped to the start/end.

[CL 2391669 by Dan Hertzka in Main branch]
2014-12-17 16:07:57 -05:00

1021 lines
30 KiB
C++
Raw Blame History

// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
#include "IntroTutorialsPrivatePCH.h"
#include "STutorialsBrowser.h"
#include "EditorTutorial.h"
#include "STutorialContent.h"
#include "TutorialSettings.h"
#include "EditorTutorialSettings.h"
#include "TutorialStateSettings.h"
#include "AssetRegistryModule.h"
#include "EngineAnalytics.h"
#include "Runtime/Analytics/Analytics/Public/Interfaces/IAnalyticsProvider.h"
#include "SSearchBox.h"
#include "SBreadcrumbTrail.h"
#define LOCTEXT_NAMESPACE "TutorialsBrowser"
class FTutorialListEntry_Tutorial;
DECLARE_DELEGATE_OneParam(FOnCategorySelected, const FString& /* InCategory */);
namespace TutorialBrowserConstants
{
const float RefreshTimerInterval = 1.0f;
const float ProgressUpdateInterval = 0.5f;
}
class FTutorialListEntry_Category : public ITutorialListEntry, public TSharedFromThis<FTutorialListEntry_Category>
{
public:
FTutorialListEntry_Category(FOnCategorySelected InOnCategorySelected)
: OnCategorySelected(InOnCategorySelected)
, SlateBrush(nullptr)
{}
FTutorialListEntry_Category(const FTutorialCategory& InCategory, FOnCategorySelected InOnCategorySelected, const TAttribute<FText>& InHighlightText)
: Category(InCategory)
, OnCategorySelected(InOnCategorySelected)
, HighlightText(InHighlightText)
, SlateBrush(nullptr)
{
if(!Category.Identifier.IsEmpty())
{
int32 Index = INDEX_NONE;
if(Category.Identifier.FindLastChar(TEXT('.'), Index))
{
CategoryName = Category.Identifier.RightChop(Index + 1);
}
else
{
CategoryName = Category.Identifier;
}
}
if(Category.Texture.IsValid())
{
UTexture2D* Texture = LoadObject<UTexture2D>(nullptr, *Category.Texture.AssetLongPathname);
if(Texture != nullptr)
{
FIntPoint TextureSize = Texture->GetImportedSize();
DynamicBrush = MakeShareable(new FSlateDynamicImageBrush(Texture, FVector2D((float)TextureSize.X, (float)TextureSize.Y), NAME_None));
SlateBrush = DynamicBrush.Get();
}
}
if(SlateBrush == nullptr)
{
if(Category.Icon.Len() > 0)
{
SlateBrush = FEditorStyle::Get().GetBrush(FName(*Category.Icon));
}
}
if(SlateBrush == nullptr)
{
SlateBrush = FEditorStyle::Get().GetBrush("Tutorials.Browser.DefaultTutorialIcon");
}
}
virtual ~FTutorialListEntry_Category()
{}
virtual TSharedRef<ITableRow> OnGenerateTutorialRow(const TSharedRef<STableViewBase>& OwnerTable) const override
{
return SNew(STableRow<TSharedPtr<ITutorialListEntry>>, OwnerTable)
[
SNew(SBox)
.Padding(FMargin(0.0f, 2.0f))
[
SNew(SButton)
.OnClicked(this, &FTutorialListEntry_Category::OnClicked)
.ButtonStyle(&FEditorStyle::Get().GetWidgetStyle<FButtonStyle>("Tutorials.Browser.Button"))
.ForegroundColor(FSlateColor::UseForeground())
.Content()
[
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.HAlign(HAlign_Center)
.Padding(8.0f)
[
SNew(SBox)
.WidthOverride(64.0f)
.HeightOverride(64.0f)
.VAlign(VAlign_Center)
.HAlign(HAlign_Center)
[
SNew(SImage)
.Image(SlateBrush)
]
]
+SHorizontalBox::Slot()
.FillWidth(1.0f)
.VAlign(VAlign_Center)
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
.AutoHeight()
[
SNew(STextBlock)
.Text(!Category.Title.IsEmpty() ? Category.Title : FText::FromString(CategoryName))
.TextStyle(&FEditorStyle::Get().GetWidgetStyle<FTextBlockStyle>("Tutorials.Browser.SummaryHeader"))
.HighlightText(HighlightText)
.HighlightColor(FEditorStyle::Get().GetColor("Tutorials.Browser.HighlightTextColor"))
.HighlightShape(FEditorStyle::Get().GetBrush("TextBlock.HighlightShape"))
]
+SVerticalBox::Slot()
.FillHeight(1.0f)
[
SNew(STextBlock)
.AutoWrapText(true)
.Text(Category.Description)
.TextStyle(&FEditorStyle::Get().GetWidgetStyle<FTextBlockStyle>("Tutorials.Browser.SummaryText"))
.HighlightText(HighlightText)
.HighlightColor(FEditorStyle::Get().GetColor("Tutorials.Browser.HighlightTextColor"))
.HighlightShape(FEditorStyle::Get().GetBrush("TextBlock.HighlightShape"))
]
]
+SHorizontalBox::Slot()
.AutoWidth()
.HAlign(HAlign_Right)
.VAlign(VAlign_Center)
[
SNew(SImage)
.Visibility(this, &FTutorialListEntry_Category::OnGetArrowVisibility)
.Image(FEditorStyle::Get().GetBrush("Tutorials.Browser.CategoryArrow"))
]
]
]
];
}
bool PassesFilter(const FString& InCategoryFilter, const FString& InFilter) const override
{
const FString Title = !Category.Title.IsEmpty() ? Category.Title.ToString() : CategoryName;
const bool bPassesFilter = InFilter.IsEmpty() || (Title.Contains(InFilter) || Category.Description.ToString().Contains(InFilter));
const bool bPassesCategory = InCategoryFilter.IsEmpty() || Category.Identifier.StartsWith(InCategoryFilter);
return bPassesFilter && bPassesCategory;
}
FString GetTitleString() const override
{
const FString Title = !Category.Title.IsEmpty() ? Category.Title.ToString() : CategoryName;
return Title;
}
FText GetTitleText() const override
{
return !Category.Title.IsEmpty() ? Category.Title : FText::FromString(CategoryName);
}
bool SortAgainst(TSharedRef<ITutorialListEntry> OtherEntry) const override
{
return GetTitleString() < OtherEntry->GetTitleString();
}
void AddSubCategory(TSharedPtr<FTutorialListEntry_Category> InSubCategory)
{
SubCategories.Add(InSubCategory);
}
void AddTutorial(TSharedPtr<FTutorialListEntry_Tutorial> InTutorial)
{
Tutorials.Add(InTutorial);
}
FReply OnClicked() const
{
if(SubCategories.Num() > 0 || Tutorials.Num() > 0)
{
OnCategorySelected.ExecuteIfBound(Category.Identifier);
}
return FReply::Handled();
}
EVisibility OnGetArrowVisibility() const
{
return (SubCategories.Num() > 0 || Tutorials.Num() > 0) ? EVisibility::Visible : EVisibility::Collapsed;
}
public:
/** Copy of the category info */
FTutorialCategory Category;
/** Parent category */
TWeakPtr<ITutorialListEntry> ParentCategory;
/** Sub-categories */
TArray<TSharedPtr<ITutorialListEntry>> SubCategories;
/** Tutorials in this category */
TArray<TSharedPtr<ITutorialListEntry>> Tutorials;
/** Selection delegate */
FOnCategorySelected OnCategorySelected;
/** Name of the category, empty if this category is at the root */
FString CategoryName;
/** Text to highlight */
TAttribute<FText> HighlightText;
/** Static brush from the editor style */
const FSlateBrush* SlateBrush;
/** Dynamic brush from the texture specified by the user */
TSharedPtr<FSlateDynamicImageBrush> DynamicBrush;
};
DECLARE_DELEGATE_TwoParams(FOnTutorialSelected, UEditorTutorial* /* InTutorial */, bool /* bRestart */ );
class FTutorialListEntry_Tutorial : public ITutorialListEntry, public TSharedFromThis<FTutorialListEntry_Tutorial>
{
public:
FTutorialListEntry_Tutorial(UEditorTutorial* InTutorial, FOnTutorialSelected InOnTutorialSelected, const TAttribute<FText>& InHighlightText)
: Tutorial(InTutorial)
, OnTutorialSelected(InOnTutorialSelected)
, HighlightText(InHighlightText)
, SlateBrush(nullptr)
, LastUpdateTime(0.0f)
{
if(Tutorial->Texture != nullptr)
{
FIntPoint TextureSize = Tutorial->Texture->GetImportedSize();
DynamicBrush = MakeShareable(new FSlateDynamicImageBrush(Tutorial->Texture, FVector2D((float)TextureSize.X, (float)TextureSize.Y), NAME_None));
SlateBrush = DynamicBrush.Get();
}
else if(Tutorial->Icon.Len() > 0)
{
SlateBrush = FEditorStyle::Get().GetBrush(FName(*Tutorial->Icon));
}
if(SlateBrush == nullptr)
{
SlateBrush = FEditorStyle::Get().GetBrush("Tutorials.Browser.DefaultTutorialIcon");
}
}
virtual ~FTutorialListEntry_Tutorial()
{}
virtual TSharedRef<ITableRow> OnGenerateTutorialRow(const TSharedRef<STableViewBase>& OwnerTable) const override
{
CacheProgress();
return SNew(STableRow<TSharedPtr<ITutorialListEntry>>, OwnerTable)
[
SNew(SBox)
.Padding(FMargin(0.0f, 2.0f))
[
SAssignNew(LaunchButton, SButton)
.OnClicked(this, &FTutorialListEntry_Tutorial::OnClicked, false)
.ButtonStyle(&FEditorStyle::Get().GetWidgetStyle<FButtonStyle>("Tutorials.Browser.Button"))
.ForegroundColor(FSlateColor::UseForeground())
.Content()
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
.AutoHeight()
[
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.HAlign(HAlign_Center)
.Padding(8.0f)
[
SNew(SOverlay)
+SOverlay::Slot()
[
SNew(SBox)
.WidthOverride(64.0f)
.HeightOverride(64.0f)
.VAlign(VAlign_Center)
.HAlign(HAlign_Center)
[
SNew(SImage)
.Image(SlateBrush)
]
]
+SOverlay::Slot()
.VAlign(VAlign_Bottom)
.HAlign(HAlign_Right)
[
SNew(SImage)
.ToolTipText(LOCTEXT("CompletedCheckToolTip", "This tutorial has been completed"))
.Visibility(this, &FTutorialListEntry_Tutorial::GetCompletedVisibility)
.Image(FEditorStyle::Get().GetBrush("Tutorials.Browser.Completed"))
]
]
+SHorizontalBox::Slot()
.FillWidth(1.0f)
.HAlign(HAlign_Fill)
.VAlign(VAlign_Center)
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
.AutoHeight()
[
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.FillWidth(1.0f)
[
SNew(STextBlock)
.Text(Tutorial->Title)
.TextStyle(&FEditorStyle::Get().GetWidgetStyle<FTextBlockStyle>("Tutorials.Browser.SummaryHeader"))
.HighlightText(HighlightText)
.HighlightColor(FEditorStyle::Get().GetColor("Tutorials.Browser.HighlightTextColor"))
.HighlightShape(FEditorStyle::Get().GetBrush("TextBlock.HighlightShape"))
]
+SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
[
SNew(SButton)
.ToolTipText(LOCTEXT("RestartButtonToolTip", "Start this tutorial from the beginning"))
.Visibility(this, &FTutorialListEntry_Tutorial::GetRestartVisibility)
.OnClicked(this, &FTutorialListEntry_Tutorial::OnClicked, true)
.ButtonStyle(&FEditorStyle::Get().GetWidgetStyle<FButtonStyle>("Tutorials.Browser.Button"))
.Content()
[
SNew(SImage)
.Image(FEditorStyle::GetBrush("Tutorials.Browser.RestartButton"))
]
]
]
+SVerticalBox::Slot()
.AutoHeight()
[
SNew(SBox)
.Visibility(this, &FTutorialListEntry_Tutorial::GetProgressVisibility)
.HeightOverride(3.0f)
[
SNew(SProgressBar)
.Percent(this, &FTutorialListEntry_Tutorial::GetProgress)
]
]
+SVerticalBox::Slot()
.FillHeight(1.0f)
[
STutorialContent::GenerateContentWidget(Tutorial->SummaryContent, DocumentationPage, HighlightText)
]
]
]
]
]
];
}
bool PassesFilter(const FString& InCategoryFilter, const FString& InFilter) const override
{
const bool bPassesFilter = InFilter.IsEmpty() || (Tutorial->Title.ToString().Contains(InFilter) || Tutorial->SummaryContent.Text.ToString().Contains(InFilter));
const bool bPassesCategory = InCategoryFilter.IsEmpty() || Tutorial->Category.StartsWith(InCategoryFilter);
return bPassesFilter && bPassesCategory;
}
FText GetTitleText() const override
{
return Tutorial->Title;
}
FString GetTitleString() const override
{
return Tutorial->Title.ToString();
}
bool SortAgainst(TSharedRef<ITutorialListEntry> OtherEntry) const override
{
return GetTitleString() < OtherEntry->GetTitleString();
}
FReply OnClicked(bool bRestart) const
{
OnTutorialSelected.ExecuteIfBound(Tutorial, bRestart);
return FReply::Handled();
}
TOptional<float> GetProgress() const
{
CacheProgress();
return Progress;
}
EVisibility GetProgressVisibility() const
{
if(LaunchButton->IsHovered())
{
CacheProgress();
return LaunchButton->IsHovered() && bHaveSeenTutorial ? EVisibility::Visible : EVisibility::Hidden;
}
return EVisibility::Hidden;
}
EVisibility GetRestartVisibility() const
{
if(LaunchButton->IsHovered())
{
CacheProgress();
return LaunchButton->IsHovered() && bHaveSeenTutorial ? EVisibility::Visible : EVisibility::Collapsed;
}
return EVisibility::Collapsed;
}
EVisibility GetCompletedVisibility() const
{
CacheProgress();
return bHaveCompletedTutorial ? EVisibility::Visible : EVisibility::Hidden;
}
void CacheProgress() const
{
if(FPlatformTime::Seconds() - LastUpdateTime > TutorialBrowserConstants::ProgressUpdateInterval)
{
bHaveCompletedTutorial = GetDefault<UTutorialStateSettings>()->HaveCompletedTutorial(Tutorial);
bHaveSeenTutorial = false;
const int32 CurrentStage = GetDefault<UTutorialStateSettings>()->GetProgress(Tutorial, bHaveSeenTutorial);
Progress = (Tutorial->Stages.Num() > 0) ? (float)(CurrentStage + 1) / (float)Tutorial->Stages.Num() : 0.0f;
LastUpdateTime = FPlatformTime::Seconds();
}
}
public:
/** Parent category */
TWeakPtr<ITutorialListEntry> ParentCategory;
/** Tutorial that we will launch */
UEditorTutorial* Tutorial;
/** Selection delegate */
FOnTutorialSelected OnTutorialSelected;
/** Text to highlight */
TAttribute<FText> HighlightText;
/** Button clicked to launch tutorial */
mutable TSharedPtr<SWidget> LaunchButton;
/** Documentation page reference to use if we are displaying a UDN doc */
mutable TSharedPtr<IDocumentationPage> DocumentationPage;
/** Static brush from the editor style */
const FSlateBrush* SlateBrush;
/** Dynamic brush from the texture specified by the user */
TSharedPtr<FSlateDynamicImageBrush> DynamicBrush;
/** Cached tutorial completion state */
mutable bool bHaveCompletedTutorial;
/** Cached tutorial seen state */
mutable bool bHaveSeenTutorial;
/** Cached tutorial progress */
mutable float Progress;
/** Last update time */
mutable float LastUpdateTime;
};
void STutorialsBrowser::Construct(const FArguments& InArgs)
{
bNeedsRefresh = false;
RefreshTimer = TutorialBrowserConstants::RefreshTimerInterval;
OnClosed = InArgs._OnClosed;
OnLaunchTutorial = InArgs._OnLaunchTutorial;
ParentWindow = InArgs._ParentWindow;
FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
AssetRegistryModule.Get().OnAssetAdded().AddSP(this, &STutorialsBrowser::HandleAssetAdded);
RegisterActiveTick( TutorialBrowserConstants::RefreshTimerInterval, FWidgetActiveTickDelegate::CreateSP( this, &STutorialsBrowser::TriggerReloadTutorials ) );
ChildSlot
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
.AutoHeight()
[
SNew(SBorder)
.BorderImage(FEditorStyle::Get().GetBrush("ToolPanel.GroupBorder"))
.Padding(5.0f)
[
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
[
SNew(SButton)
.OnClicked(this, &STutorialsBrowser::OnBackButtonClicked)
.IsEnabled(this, &STutorialsBrowser::IsBackButtonEnabled)
.ButtonStyle(&FEditorStyle::Get().GetWidgetStyle<FButtonStyle>("Tutorials.Browser.BackButton"))
.ForegroundColor(FSlateColor::UseForeground())
.Content()
[
SNew(SImage)
.Image(FEditorStyle::GetBrush("Tutorials.Browser.BackButton.Image"))
]
]
+SHorizontalBox::Slot()
.FillWidth(1.0f)
.VAlign(VAlign_Center)
.Padding(2.0f, 0.0f, 0.0f, 0.0f)
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
.AutoHeight()
.Padding(0.0f, 1.0f)
[
SAssignNew(BreadcrumbTrail, SBreadcrumbTrail<TSharedPtr<ITutorialListEntry>>)
.ButtonContentPadding(FMargin(1.0f, 1.0f))
.DelimiterImage(FEditorStyle::GetBrush("Tutorials.Browser.Breadcrumb"))
.TextStyle(FEditorStyle::Get(), "Tutorials.Browser.PathText")
.ShowLeadingDelimiter( true )
.InvertTextColorOnHover( false )
.OnCrumbClicked(this, &STutorialsBrowser::OnBreadcrumbClicked)
]
+SVerticalBox::Slot()
.AutoHeight()
.Padding(0.0f, 1.0f)
[
SNew(SSearchBox)
.OnTextChanged(this, &STutorialsBrowser::OnSearchTextChanged)
]
]
]
]
+SVerticalBox::Slot()
.FillHeight(1.0f)
.Padding(0.0f, 3.0f, 0.0f, 0.0f)
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
.FillHeight(1.0f)
[
SNew(SScrollBox)
+SScrollBox::Slot()
[
SAssignNew(TutorialList, SListView<TSharedPtr<ITutorialListEntry>>)
.ItemHeight(128.0f)
.ListItemsSource(&FilteredEntries)
.OnGenerateRow(this, &STutorialsBrowser::OnGenerateTutorialRow)
.SelectionMode(ESelectionMode::None)
]
]
]
];
ReloadTutorials();
RebuildCrumbs();
}
EActiveTickReturnType STutorialsBrowser::TriggerReloadTutorials( double InCurrentTime, float InDeltaTime )
{
if (bNeedsRefresh)
{
bNeedsRefresh = false;
ReloadTutorials();
}
return EActiveTickReturnType::KeepTicking;
}
void STutorialsBrowser::SetFilter(const FString& InFilter)
{
CategoryFilter = InFilter;
ReloadTutorials();
}
TSharedRef<ITableRow> STutorialsBrowser::OnGenerateTutorialRow(TSharedPtr<ITutorialListEntry> InItem, const TSharedRef<STableViewBase>& OwnerTable) const
{
return InItem->OnGenerateTutorialRow(OwnerTable);
}
TSharedPtr<FTutorialListEntry_Category> STutorialsBrowser::RebuildCategories()
{
TArray<TSharedPtr<FTutorialListEntry_Category>> Categories;
// add root category
TSharedPtr<FTutorialListEntry_Category> RootCategory = MakeShareable(new FTutorialListEntry_Category(FOnCategorySelected::CreateSP(this, &STutorialsBrowser::OnCategorySelected)));
Categories.Add(RootCategory);
// rebuild categories
for(const auto& TutorialCategory : GetDefault<UTutorialSettings>()->Categories)
{
Categories.Add(MakeShareable(new FTutorialListEntry_Category(TutorialCategory, FOnCategorySelected::CreateSP(this, &STutorialsBrowser::OnCategorySelected), TAttribute<FText>::Create(TAttribute<FText>::FGetter::CreateSP(this, &STutorialsBrowser::GetSearchText)))));
}
for(const auto& TutorialCategory : GetDefault<UEditorTutorialSettings>()->Categories)
{
Categories.Add(MakeShareable(new FTutorialListEntry_Category(TutorialCategory, FOnCategorySelected::CreateSP(this, &STutorialsBrowser::OnCategorySelected), TAttribute<FText>::Create(TAttribute<FText>::FGetter::CreateSP(this, &STutorialsBrowser::GetSearchText)))));
}
for(auto& Category : Categories)
{
// Figure out which base category this category belongs in
TSharedPtr<FTutorialListEntry_Category> ParentCategory = RootCategory;
const FString& CategoryPath = Category->Category.Identifier;
// We're expecting the category string to be in the "A.B.C" format. We'll split up the string here and form
// a proper hierarchy in the UI
TArray< FString > SplitCategories;
CategoryPath.ParseIntoArray( &SplitCategories, TEXT( "." ), true /* bCullEmpty */ );
FString CurrentCategoryPath;
// Make sure all of the categories exist
for(const auto& SplitCategory : SplitCategories)
{
// Locate this category at the level we're at in the hierarchy
TSharedPtr<FTutorialListEntry_Category> FoundCategory = NULL;
TArray< TSharedPtr<ITutorialListEntry> >& TestCategoryList = ParentCategory.IsValid() ? ParentCategory->SubCategories : RootCategory->SubCategories;
for(auto& TestCategory : TestCategoryList)
{
if( StaticCastSharedPtr<FTutorialListEntry_Category>(TestCategory)->CategoryName == SplitCategory )
{
// Found it!
FoundCategory = StaticCastSharedPtr<FTutorialListEntry_Category>(TestCategory);
break;
}
}
if(!CurrentCategoryPath.IsEmpty())
{
CurrentCategoryPath += TEXT(".");
}
CurrentCategoryPath += SplitCategory;
if( !FoundCategory.IsValid() )
{
// OK, this is a new category name for us, so add it now!
if(CategoryPath == CurrentCategoryPath)
{
FoundCategory = Category;
}
else
{
FTutorialCategory InterveningCategory;
InterveningCategory.Identifier = CurrentCategoryPath;
FoundCategory = MakeShareable(new FTutorialListEntry_Category(InterveningCategory, FOnCategorySelected::CreateSP(this, &STutorialsBrowser::OnCategorySelected), TAttribute<FText>::Create(TAttribute<FText>::FGetter::CreateSP(this, &STutorialsBrowser::GetSearchText))));
}
FoundCategory->ParentCategory = ParentCategory;
TestCategoryList.Add( FoundCategory );
}
// Descend the hierarchy for the next category
ParentCategory = FoundCategory;
}
}
return RootCategory;
}
void STutorialsBrowser::RebuildTutorials(TSharedPtr<FTutorialListEntry_Category> InRootCategory)
{
TArray<TSharedPtr<FTutorialListEntry_Tutorial>> Tutorials;
// rebuild tutorials
FAssetRegistryModule& AssetRegistry = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
FARFilter Filter;
Filter.ClassNames.Add(UBlueprint::StaticClass()->GetFName());
Filter.bRecursiveClasses = true;
Filter.TagsAndValues.Add(TEXT("ParentClass"), FString::Printf(TEXT("%s'%s'"), *UClass::StaticClass()->GetName(), *UEditorTutorial::StaticClass()->GetPathName()));
TArray<FAssetData> AssetData;
AssetRegistry.Get().GetAssets(Filter, AssetData);
for (const auto& TutorialAsset : AssetData)
{
UBlueprint* Blueprint = LoadObject<UBlueprint>(nullptr, *TutorialAsset.ObjectPath.ToString());
if (Blueprint && Blueprint->GeneratedClass && Blueprint->BlueprintType == BPTYPE_Normal)
{
UEditorTutorial* Tutorial = Blueprint->GeneratedClass->GetDefaultObject<UEditorTutorial>();
if(!Tutorial->bHideInBrowser)
{
Tutorials.Add(MakeShareable(new FTutorialListEntry_Tutorial(Tutorial, FOnTutorialSelected::CreateSP(this, &STutorialsBrowser::OnTutorialSelected), TAttribute<FText>::Create(TAttribute<FText>::FGetter::CreateSP(this, &STutorialsBrowser::GetSearchText)))));
}
}
}
// add tutorials to categories
for(const auto& Tutorial : Tutorials)
{
// Figure out which base category this tutorial belongs in
TSharedPtr<FTutorialListEntry_Category> CategoryForTutorial = InRootCategory;
const FString& CategoryPath = Tutorial->Tutorial->Category;
// We're expecting the category string to be in the "A.B.C" format. We'll split up the string here and form
// a proper hierarchy in the UI
TArray< FString > SplitCategories;
CategoryPath.ParseIntoArray( &SplitCategories, TEXT( "." ), true /* bCullEmpty */ );
FString CurrentCategoryPath;
// Make sure all of the categories exist
for(const auto& SplitCategory : SplitCategories)
{
// Locate this category at the level we're at in the hierarchy
TSharedPtr<FTutorialListEntry_Category> FoundCategory = NULL;
TArray< TSharedPtr<ITutorialListEntry> >& TestCategoryList = CategoryForTutorial.IsValid() ? CategoryForTutorial->SubCategories : InRootCategory->SubCategories;
for(auto& TestCategory : TestCategoryList)
{
if( StaticCastSharedPtr<FTutorialListEntry_Category>(TestCategory)->CategoryName == SplitCategory )
{
// Found it!
FoundCategory = StaticCastSharedPtr<FTutorialListEntry_Category>(TestCategory);
break;
}
}
if(!CurrentCategoryPath.IsEmpty())
{
CurrentCategoryPath += TEXT(".");
}
CurrentCategoryPath += SplitCategory;
if( !FoundCategory.IsValid() )
{
// OK, this is a new category name for us, so add it now!
FTutorialCategory InterveningCategory;
InterveningCategory.Identifier = CurrentCategoryPath;
FoundCategory = MakeShareable(new FTutorialListEntry_Category(InterveningCategory, FOnCategorySelected::CreateSP(this, &STutorialsBrowser::OnCategorySelected), TAttribute<FText>::Create(TAttribute<FText>::FGetter::CreateSP(this, &STutorialsBrowser::GetSearchText))));
FoundCategory->ParentCategory = CategoryForTutorial;
TestCategoryList.Add( FoundCategory );
}
// Descend the hierarchy for the next category
CategoryForTutorial = FoundCategory;
}
Tutorial->ParentCategory = CategoryForTutorial;
CategoryForTutorial->AddTutorial( Tutorial );
}
}
void STutorialsBrowser::ReloadTutorials()
{
TSharedPtr<FTutorialListEntry_Category> RootCategory = RebuildCategories();
RebuildTutorials(RootCategory);
RootEntry = RootCategory;
// now filter & arrange available tutorials
FilterTutorials();
}
FReply STutorialsBrowser::OnCloseButtonClicked()
{
OnClosed.ExecuteIfBound();
return FReply::Handled();
}
FReply STutorialsBrowser::OnBackButtonClicked()
{
TSharedPtr<FTutorialListEntry_Category> CurrentCategory = FindCategory_Recursive(RootEntry);
if(CurrentCategory.IsValid() && CurrentCategory->ParentCategory.IsValid())
{
TSharedPtr<FTutorialListEntry_Category> PinnedParentCategory = StaticCastSharedPtr<FTutorialListEntry_Category>(CurrentCategory->ParentCategory.Pin());
if(PinnedParentCategory.IsValid())
{
NavigationFilter = PinnedParentCategory->Category.Identifier;
FilterTutorials();
}
}
RebuildCrumbs();
return FReply::Handled();
}
bool STutorialsBrowser::IsBackButtonEnabled() const
{
if(CurrentCategoryPtr.IsValid())
{
return CurrentCategoryPtr.Pin()->ParentCategory.IsValid();
}
return false;
}
void STutorialsBrowser::OnTutorialSelected(UEditorTutorial* InTutorial, bool bRestart)
{
if( FEngineAnalytics::IsAvailable() && InTutorial != nullptr )
{
TArray<FAnalyticsEventAttribute> EventAttributes;
EventAttributes.Add(FAnalyticsEventAttribute(TEXT("Restarted"), bRestart));
EventAttributes.Add(FAnalyticsEventAttribute(TEXT("TutorialAsset"), FIntroTutorials::AnalyticsEventNameFromTutorial(InTutorial)));
FEngineAnalytics::GetProvider().RecordEvent( TEXT("Rocket.Tutorials.LaunchedFromBrowser"), EventAttributes );
}
OnLaunchTutorial.ExecuteIfBound(InTutorial, bRestart, ParentWindow, FSimpleDelegate(), FSimpleDelegate());
}
void STutorialsBrowser::OnCategorySelected(const FString& InCategory)
{
NavigationFilter = InCategory;
FilterTutorials();
RebuildCrumbs();
}
void STutorialsBrowser::FilterTutorials()
{
FilteredEntries.Empty();
if(SearchFilter.IsEmpty())
{
TSharedPtr<FTutorialListEntry_Category> CurrentCategory = FindCategory_Recursive(RootEntry);
if(CurrentCategory.IsValid())
{
for(const auto& SubCategory : CurrentCategory->SubCategories)
{
if(SubCategory->PassesFilter(CategoryFilter, SearchFilter.ToString()))
{
FilteredEntries.Add(SubCategory);
}
}
for(const auto& Tutorial : CurrentCategory->Tutorials)
{
if(Tutorial->PassesFilter(CategoryFilter, SearchFilter.ToString()))
{
FilteredEntries.Add(Tutorial);
}
}
CurrentCategoryPtr = CurrentCategory;
}
}
else
{
struct Local
{
static void AddSubCategory_Recursive(const FString& InCategoryFilter, const FString& InSearchFilter, TSharedPtr<FTutorialListEntry_Category> InCategory, TArray<TSharedPtr<ITutorialListEntry>>& InOutFilteredEntries)
{
if(InCategory.IsValid())
{
for(const auto& SubCategory : InCategory->SubCategories)
{
if(SubCategory->PassesFilter(InCategoryFilter, InSearchFilter))
{
InOutFilteredEntries.Add(SubCategory);
}
AddSubCategory_Recursive(InCategoryFilter, InSearchFilter, StaticCastSharedPtr<FTutorialListEntry_Category>(SubCategory), InOutFilteredEntries);
}
for(const auto& Tutorial : InCategory->Tutorials)
{
if(Tutorial->PassesFilter(InCategoryFilter, InSearchFilter))
{
InOutFilteredEntries.Add(Tutorial);
}
}
}
};
};
TSharedPtr<FTutorialListEntry_Category> CurrentCategory = FindCategory_Recursive(RootEntry);
if(CurrentCategory.IsValid())
{
Local::AddSubCategory_Recursive(CategoryFilter, SearchFilter.ToString(), CurrentCategory, FilteredEntries);
CurrentCategoryPtr = CurrentCategory;
}
}
FilteredEntries.Sort(
[](TSharedPtr<ITutorialListEntry> EntryA, TSharedPtr<ITutorialListEntry> EntryB)->bool
{
if(EntryA.IsValid() && EntryB.IsValid())
{
return EntryA->SortAgainst(EntryB.ToSharedRef());
}
return false;
}
);
TutorialList->RequestListRefresh();
}
TSharedPtr<FTutorialListEntry_Category> STutorialsBrowser::FindCategory_Recursive(TSharedPtr<FTutorialListEntry_Category> InCategory) const
{
if(InCategory.IsValid())
{
if(InCategory->Category.Identifier == NavigationFilter)
{
return InCategory;
}
for(const auto& Category : InCategory->SubCategories)
{
TSharedPtr<FTutorialListEntry_Category> TestCategory = FindCategory_Recursive(StaticCastSharedPtr<FTutorialListEntry_Category>(Category));
if(TestCategory.IsValid())
{
return TestCategory;
}
}
}
return TSharedPtr<FTutorialListEntry_Category>();
}
void STutorialsBrowser::OnSearchTextChanged(const FText& InText)
{
SearchFilter = InText;
FilterTutorials();
}
FText STutorialsBrowser::GetSearchText() const
{
return SearchFilter;
}
void STutorialsBrowser::OnBreadcrumbClicked(const TSharedPtr<ITutorialListEntry>& InEntry)
{
TSharedPtr<ITutorialListEntry> ClickedEntry = InEntry;
if(ClickedEntry.IsValid())
{
NavigationFilter = StaticCastSharedPtr<FTutorialListEntry_Category>(ClickedEntry)->Category.Identifier;
}
else
{
NavigationFilter.Empty();
}
RebuildCrumbs();
FilterTutorials();
}
void STutorialsBrowser::RebuildCrumbs()
{
BreadcrumbTrail->ClearCrumbs();
// rebuild crumbs to this point
TArray<TSharedPtr<FTutorialListEntry_Category>> Entries;
TSharedPtr<FTutorialListEntry_Category> CurrentCategory = FindCategory_Recursive(RootEntry);
if(CurrentCategory.IsValid())
{
TSharedPtr<FTutorialListEntry_Category> Category = StaticCastSharedPtr<FTutorialListEntry_Category>(CurrentCategory);
while(Category.IsValid())
{
Entries.Add(Category);
if(Category->ParentCategory.IsValid())
{
Category = StaticCastSharedPtr<FTutorialListEntry_Category>(Category->ParentCategory.Pin());
}
else
{
break;
}
}
}
for(int32 Index = Entries.Num() - 1; Index >= 0; Index--)
{
TSharedPtr<FTutorialListEntry_Category> Entry = Entries[Index];
if(RootEntry == Entry)
{
BreadcrumbTrail->PushCrumb(LOCTEXT("PathRoot", "Tutorials"), TSharedPtr<ITutorialListEntry>());
}
else
{
BreadcrumbTrail->PushCrumb(Entry->GetTitleText(), Entry);
}
}
}
void STutorialsBrowser::HandleAssetAdded(const FAssetData& InAssetData)
{
if(InAssetData.AssetClass == UBlueprint::StaticClass()->GetFName())
{
const FString* ParentClassPath = InAssetData.TagsAndValues.Find(TEXT("ParentClass"));
if(ParentClassPath != nullptr)
{
UClass* ParentClass = FindObject<UClass>(NULL, **ParentClassPath);
if(ParentClass == UEditorTutorial::StaticClass())
{
bNeedsRefresh = true;
}
}
}
}
#undef LOCTEXT_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink