232 lines
9.8 KiB
C++
232 lines
9.8 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
#pragma once
|
|
|
|
#include "EditorUndoClient.h"
|
|
#include "ICompElementManager.h" // for ICompElementManager::FOnElementsChanged
|
|
#include "UObject/WeakObjectPtr.h"
|
|
|
|
class UEditorEngine;
|
|
class FCompElementViewModel;
|
|
class UClass;
|
|
class FUICommandList;
|
|
|
|
template<typename TItemType> class IFilter;
|
|
typedef IFilter<const TSharedPtr<FCompElementViewModel>&> FCompElementFilter;
|
|
|
|
template<typename ItemType> class TFilterCollection;
|
|
typedef TFilterCollection<const TSharedPtr<FCompElementViewModel>&> FCompElementFilterCollection;
|
|
|
|
/**
|
|
* The non-UI solution specific presentation logic for a comp elements' view.
|
|
*/
|
|
class FCompElementCollectionViewModel : public TSharedFromThis<FCompElementCollectionViewModel>, public FEditorUndoClient
|
|
{
|
|
public:
|
|
/**
|
|
* Factory method which creates a new FCompElementCollectionViewModel object.
|
|
*
|
|
* @param InElementsManager The element management logic object
|
|
* @param InEditor The UEditorEngine to register with (for undo/redo, etc.)
|
|
*/
|
|
static TSharedRef<FCompElementCollectionViewModel> Create(const TSharedRef<ICompElementManager>& InElementsManager, const TWeakObjectPtr<UEditorEngine>& InEditor)
|
|
{
|
|
TSharedRef<FCompElementCollectionViewModel> ElementsView(new FCompElementCollectionViewModel(InElementsManager, InEditor));
|
|
ElementsView->Initialize();
|
|
|
|
return ElementsView;
|
|
}
|
|
|
|
virtual ~FCompElementCollectionViewModel();
|
|
|
|
public:
|
|
//~ Begin FEditorUndoClient interface
|
|
virtual void PostUndo(bool bSuccess) override { Refresh(); }
|
|
virtual void PostRedo(bool bSuccess) override { PostUndo(bSuccess); }
|
|
//~ End FEditorUndoClient interface
|
|
|
|
/**
|
|
* Hook for the UI search box (and others) to filter the model's element list.
|
|
*/
|
|
void AddFilter(const TSharedRef<FCompElementFilter>& InFilter);
|
|
|
|
/**
|
|
* Clears an existing filter from the elements list (refreshes the lists returned by GetCompShots() and GetElementsForComp()
|
|
*/
|
|
void RemoveFilter(const TSharedRef<FCompElementFilter>& InFilter);
|
|
|
|
/**
|
|
* Returns the (filtered) list of top-level compositing elements (for the UI to display).
|
|
*/
|
|
TArray< TSharedPtr<FCompElementViewModel> >& GetRootCompElements();
|
|
|
|
/**
|
|
* Returns a (filtered) list of child elements, nested directly under the specified CompItem.
|
|
*/
|
|
void GetChildElements(TSharedPtr<FCompElementViewModel> ParentPtr, TArray< TSharedPtr<FCompElementViewModel> >& OutChildElements);
|
|
|
|
/**
|
|
* Some elements are not selectable (like child actors). This determines that and returns the
|
|
* (parent) element that should be selected instead.
|
|
* If the specified element is selectable, then this just returns that element.
|
|
*/
|
|
TSharedPtr<FCompElementViewModel> GetSelectionProxy(const TSharedPtr<FCompElementViewModel>& SelectedItem) const;
|
|
|
|
/** Returns the a list of element model that are currently tracked as selected (should be reflected in the UI). */
|
|
const TArray< TSharedPtr<FCompElementViewModel> >& GetSelectedElements() const;
|
|
|
|
/** Appends the names of the currently selected elements to the provided array. */
|
|
void GetSelectedElementNames(OUT TArray<FName>& OutSelectedElementNames) const;
|
|
|
|
/** Sets the specified array of element objects as the currently selected elements (provides a way to sync with the UI). */
|
|
void SetSelectedElements(const TArray< TSharedPtr<FCompElementViewModel> >& InSelectedElements);
|
|
|
|
/** Sets the current selection to the specified element. */
|
|
void SetSelectedElement(const FName& ElementName);
|
|
|
|
/** Returns the bound UICommandList for the comp element view. */
|
|
const TSharedRef<FUICommandList> GetCommandList() const;
|
|
|
|
/********************************************************************
|
|
* EVENTS
|
|
********************************************************************/
|
|
|
|
/** Broadcasts whenever one or more elements change. */
|
|
DECLARE_DERIVED_EVENT(FCompElementCollectionViewModel, ICompElementManager::FOnElementsChanged, FOnElementsChanged);
|
|
FOnElementsChanged& OnElementsChanged() { return ElementsChanged; }
|
|
|
|
/** Broadcasts whenever the currently selected elements change. */
|
|
DECLARE_EVENT(FCompElementCollectionViewModel, FOnSelectionChanged);
|
|
FOnSelectionChanged& OnSelectionChanged() { return SelectionChanged; }
|
|
|
|
/** Broadcasts whenever a rename is requested on the selected elements. */
|
|
DECLARE_EVENT(FCompElementCollectionViewModel, FOnRenameRequested);
|
|
FOnRenameRequested& OnRenameRequested() { return RenameRequested; }
|
|
|
|
private:
|
|
/**
|
|
* Private constructor to force users to go through Create(), which properly initializes the model.
|
|
*
|
|
* @param InElementsManager The element management logic object
|
|
* @param InEditor The UEditorEngine to register with (for undo/redo, etc.)
|
|
*/
|
|
FCompElementCollectionViewModel(const TSharedRef<ICompElementManager>& InElementsManager, const TWeakObjectPtr<UEditorEngine>& InEditor);
|
|
|
|
/** Initializes the elements view for use. */
|
|
void Initialize();
|
|
/** Binds all element browser commands to delegates. */
|
|
void BindCommands();
|
|
|
|
/** Refreshes any cached information. */
|
|
void Refresh();
|
|
|
|
/** Handles updating the view-model when one of its filters changes. */
|
|
void OnFilterChanged();
|
|
/** */
|
|
void OnElementsChanged(const ECompElementEdActions Action, const TWeakObjectPtr<ACompositingElement>& ChangedComp, const FName& ChangedProperty);
|
|
/** */
|
|
void OnElementAdded(const TWeakObjectPtr<ACompositingElement>& AddedElement);
|
|
/** Handles updating the internal view-models when elements are deleted */
|
|
void OnElementDelete();
|
|
/** */
|
|
void OnElementAttached(const TWeakObjectPtr<ACompositingElement>& AttachedElement);
|
|
/** Refreshes the elements list */
|
|
void OnResetElements();
|
|
|
|
/** Discards any element view-models which are invalid */
|
|
void DestructivelyPurgeInvalidViewModels(TArray< TWeakObjectPtr<ACompositingElement> >& InElements);
|
|
/** Creates view-models for all elements in the specified list */
|
|
void CreateViewModels(TArray< TWeakObjectPtr<ACompositingElement> >& ActualElements);
|
|
/** Updates the view-model hierarchy of known elements. */
|
|
void RebuildViewModelHierarchy();
|
|
/** Rebuilds the list of filtered elements. */
|
|
void RefreshFilteredElements();
|
|
/** Sorts the filtered elements list */
|
|
void SortFilteredElements();
|
|
|
|
/** Looks up the view-model associated with the specified element object. */
|
|
TSharedPtr<FCompElementViewModel> GetViewModel(TWeakObjectPtr<ACompositingElement> ElementObj);
|
|
/** Looks up the view-model associated with the specified element object. Returns false if it couldn't find one. */
|
|
bool TryGetViewModel(TWeakObjectPtr<ACompositingElement> CompObjPtr, TSharedPtr<FCompElementViewModel>& OutViewModel);
|
|
/** Returns a flat list of all element view-models (parents and children). */
|
|
void GetAllViewModels(TArray< TSharedPtr<FCompElementViewModel> >& OutAllViewModels);
|
|
|
|
/** Appends the selected element names to the specified array */
|
|
void AppendSelectedElementNames(TArray<FName>& OutElementNames) const;
|
|
/** Updates the element selection from a selection made in the level editor. */
|
|
void OnActorSelectionChanged(const TArray<UObject*>& NewSelection, bool bForceRefresh);
|
|
/** Updates actor selections from the internal selection state. */
|
|
void RefreshActorSelections() const;
|
|
|
|
private:
|
|
/** Creates a new top-level element, prompting the user to pick the class type first. */
|
|
void CreateTopLevelElement_Executed();
|
|
FName GenerateUniqueCompName() const;
|
|
bool CreateTopLevelElement_CanExecute() const;
|
|
|
|
/** Creates a new child element, nesting it under the currently selected element. */
|
|
void CreateChildElement_Executed();
|
|
FName GenerateUniqueElementName(TSubclassOf<ACompositingElement> ElementClass) const;
|
|
bool CreateChildElement_CanExecute() const;
|
|
|
|
/** Cuts the currently selected element */
|
|
void CutElements_Executed();
|
|
bool CutElements_CanExecute() const;
|
|
|
|
/** Copies the currently selected elements */
|
|
void CopyElements_Executed();
|
|
bool CopyElements_CanExecute() const;
|
|
|
|
/** Pastes the currently selected elements */
|
|
void PasteElements_Executed();
|
|
bool PasteElements_CanExecute() const;
|
|
|
|
/** Duplicates the currently selected elements */
|
|
void DuplicateElements_Executed();
|
|
bool DuplicateElements_CanExecute() const;
|
|
|
|
/** Deletes the currently selected elements */
|
|
void DeleteElements_Executed();
|
|
bool DeleteElements_CanExecute() const;
|
|
|
|
/** Requests renaming of the selected element */
|
|
void RequestRenameElement_Executed();
|
|
bool RequestRenameElement_CanExecute() const;
|
|
|
|
/** Opens a modeless dialog window, displaying the element's render result live. */
|
|
void OpenPreview_Executed();
|
|
bool OpenPreview_CanExecute() const;
|
|
/** Resets/Rebuilds the element list (useful in case the list gets stale by an unaccounted problem). */
|
|
void RefreshList_Executed();
|
|
bool RefreshList_CanExecute() const;
|
|
|
|
private:
|
|
/** The element management logic object. */
|
|
const TSharedRef<ICompElementManager> CompElementManager;
|
|
/** The UEditorEngine to use. */
|
|
const TWeakObjectPtr<UEditorEngine> Editor;
|
|
/** The list of commands with bound delegates for the element browser. */
|
|
const TSharedRef<FUICommandList> CommandList;
|
|
|
|
/** All top-level elements managed by the view. */
|
|
TArray< TSharedPtr<FCompElementViewModel> > RootViewModels;
|
|
|
|
/** The collection of filters used to restrict the elements shown in the view. */
|
|
const TSharedRef<FCompElementFilterCollection> Filters;
|
|
|
|
/** All elements shown in the view. */
|
|
TArray< TSharedPtr<FCompElementViewModel> > FilteredRootItems;
|
|
typedef TMultiMap< TSharedPtr<FCompElementViewModel>, TSharedPtr<FCompElementViewModel> > FFilteredChildList;
|
|
FFilteredChildList FilteredChildren;
|
|
|
|
/** Currently selected elements. */
|
|
TArray< TSharedPtr<FCompElementViewModel> > SelectedElements;
|
|
|
|
/** Broadcasts whenever one or more elements change. */
|
|
FOnElementsChanged ElementsChanged;
|
|
/** Broadcasts whenever the currently selected elements change. */
|
|
FOnSelectionChanged SelectionChanged;
|
|
/** Broadcasts whenever a rename is requested on the selected elements. */
|
|
FOnRenameRequested RenameRequested;
|
|
};
|
|
|