2014-12-07 19:09:38 -05:00
// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
2014-03-14 14:13:41 -04:00
# include "DeviceProfileEditorPCH.h"
2014-05-29 17:11:10 -04:00
# include "DeviceProfiles/DeviceProfileManager.h"
# include "DeviceProfiles/DeviceProfile.h"
2014-04-02 18:09:23 -04:00
# include "ISourceControlModule.h"
2014-03-14 14:13:41 -04:00
# include "PropertyEditorModule.h"
# include "PropertyPath.h"
2014-10-14 22:50:06 -04:00
# include "SDockTab.h"
# include "SWidgetSwitcher.h"
2014-03-14 14:13:41 -04:00
# define LOCTEXT_NAMESPACE "DeviceProfileEditor"
// Tab names for those available in the Device Profile Editor.
static const FName DeviceProfileEditorTabName ( " DeviceProfiles " ) ;
2014-04-02 18:09:23 -04:00
/** Source control for the default device profile config saves */
2014-09-21 20:35:48 -04:00
class SDeviceProfileSourceControl
: public SCompoundWidget
2014-04-02 18:09:23 -04:00
{
public :
SLATE_BEGIN_ARGS ( SDeviceProfileSourceControl ) { }
SLATE_DEFAULT_SLOT ( FArguments , Content )
SLATE_END_ARGS ( )
2014-09-21 20:35:48 -04:00
/** Constructs this widget with InArgs. */
2014-04-02 18:09:23 -04:00
void Construct ( const FArguments & InArgs ) ;
2014-09-21 20:35:48 -04:00
/** Destructor. */
2014-04-02 18:09:23 -04:00
~ SDeviceProfileSourceControl ( ) ;
/**
* Indicate which SWidgetSwitcher slot should be used to show the user of the source control status
*/
int32 HandleNoticeSwitcherWidgetIndex ( ) const
{
return bIsDefaultConfigCheckOutNeeded ? 1 : 0 ;
}
/**
2014-09-21 20:35:48 -04:00
* Take action to check out the default device profile configuration file when requested .
2014-04-02 18:09:23 -04:00
*
2014-09-21 20:35:48 -04:00
* @ return Whether we handled the event .
2014-04-02 18:09:23 -04:00
*/
FReply HandleSaveDefaultsButtonPressed ( ) ;
/**
2014-09-21 20:35:48 -04:00
* Take action to check out the default device profile configuration file when requested .
2014-04-02 18:09:23 -04:00
*
2014-09-21 20:35:48 -04:00
* @ return Whether we handled the event .
2014-04-02 18:09:23 -04:00
*/
FReply HandleCheckoutButtonPressed ( ) ;
/**
* Check whether the SCC is enabled for the Checkout button to become available .
2014-09-21 20:35:48 -04:00
*
* @ return true if SCC is enabled , false otherwise .
2014-04-02 18:09:23 -04:00
*/
bool IsCheckOutAvailable ( ) const ;
public :
2014-09-21 20:35:48 -04:00
// SCompoundWidget interface
2014-04-02 18:09:23 -04:00
---- 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
virtual void Tick ( const FGeometry & AllottedGeometry , const double InCurrentTime , const float InDeltaTime ) override ;
2014-04-02 18:09:23 -04:00
private :
---- 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
/** Holds the last time checking whether the device profile configuration file needs to be checked out. */
double LastDefaultConfigCheckOutTime ;
2014-04-02 18:09:23 -04:00
2014-09-21 20:35:48 -04:00
/** Holds a flag indicating whether the section's configuration file needs to be checked out. */
2014-04-02 18:09:23 -04:00
bool bIsDefaultConfigCheckOutNeeded ;
2014-09-21 20:35:48 -04:00
/** The direct path to the default device profile config file. */
2014-04-02 18:09:23 -04:00
FString AbsoluteConfigFilePath ;
} ;
SDeviceProfileSourceControl : : ~ SDeviceProfileSourceControl ( )
{
}
FReply SDeviceProfileSourceControl : : HandleSaveDefaultsButtonPressed ( )
{
2015-03-17 09:50:32 -04:00
UDeviceProfileManager : : Get ( ) . SaveProfiles ( true ) ;
2014-04-02 18:09:23 -04:00
return FReply : : Handled ( ) ;
}
FReply SDeviceProfileSourceControl : : HandleCheckoutButtonPressed ( )
{
ISourceControlProvider & SourceControlProvider = ISourceControlModule : : Get ( ) . GetProvider ( ) ;
FSourceControlStatePtr SourceControlState = SourceControlProvider . GetState ( AbsoluteConfigFilePath , EStateCacheUsage : : ForceUpdate ) ;
FText ErrorMessage ;
if ( bIsDefaultConfigCheckOutNeeded & & SourceControlState . IsValid ( ) & & ( SourceControlState - > CanCheckout ( ) | | SourceControlState - > IsCheckedOutOther ( ) ) )
{
TArray < FString > FilesToBeCheckedOut ;
FilesToBeCheckedOut . Add ( AbsoluteConfigFilePath ) ;
2014-04-23 19:31:56 -04:00
if ( SourceControlProvider . Execute ( ISourceControlOperation : : Create < FCheckOut > ( ) , FilesToBeCheckedOut ) = = ECommandResult : : Failed )
2014-04-02 18:09:23 -04:00
{
ErrorMessage = LOCTEXT ( " FailedToCheckOutConfigFileError " , " Error: Failed to check out the configuration file. " ) ;
}
}
// show errors, if any
if ( ! ErrorMessage . IsEmpty ( ) )
{
FMessageDialog : : Open ( EAppMsgType : : Ok , ErrorMessage ) ;
}
return FReply : : Handled ( ) ;
}
bool SDeviceProfileSourceControl : : IsCheckOutAvailable ( ) const
{
return ISourceControlModule : : Get ( ) . IsEnabled ( ) & & ISourceControlModule : : Get ( ) . GetProvider ( ) . IsAvailable ( ) ;
}
void SDeviceProfileSourceControl : : Construct ( const FArguments & InArgs )
{
---- 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
LastDefaultConfigCheckOutTime = 0.0 ;
2014-04-02 18:09:23 -04:00
bIsDefaultConfigCheckOutNeeded = true ;
const FString RelativeConfigFilePath = FString : : Printf ( TEXT ( " %sDefault%ss.ini " ) , * FPaths : : SourceConfigDir ( ) , * UDeviceProfile : : StaticClass ( ) - > GetName ( ) ) ;
AbsoluteConfigFilePath = FPaths : : ConvertRelativePathToFull ( RelativeConfigFilePath ) ;
ChildSlot
[
SNew ( SBorder )
. BorderBackgroundColor ( FLinearColor : : Yellow )
. BorderImage ( FEditorStyle : : GetBrush ( " ToolPanel.GroupBorder " ) )
. Padding ( 8.0f )
[
SNew ( SBox )
. VAlign ( VAlign_Center )
. Content ( )
[
SNew ( SWidgetSwitcher )
. WidgetIndex ( this , & SDeviceProfileSourceControl : : HandleNoticeSwitcherWidgetIndex )
// Unlocked slot
+ SWidgetSwitcher : : Slot ( )
[
SNew ( SHorizontalBox )
+ SHorizontalBox : : Slot ( )
. VAlign ( VAlign_Center )
. AutoWidth ( )
[
SNew ( SImage )
. Image ( FEditorStyle : : GetBrush ( " GenericUnlock " ) )
]
+ SHorizontalBox : : Slot ( )
. VAlign ( VAlign_Center )
. Padding ( FMargin ( 8.0f , 0.0f ) )
. AutoWidth ( )
[
SNew ( STextBlock )
. Text ( LOCTEXT ( " DeviceProfileEditorSCCUnlockedLabel " , " The default device profile configuration is under Source Control. This file is currently writable. " ) )
]
+ SHorizontalBox : : Slot ( )
. HAlign ( HAlign_Right )
[
SNew ( SButton )
. OnClicked ( this , & SDeviceProfileSourceControl : : HandleSaveDefaultsButtonPressed )
. Text ( LOCTEXT ( " SaveAsDefaultButtonText " , " Save as Default " ) )
]
]
// Locked slot
+ SWidgetSwitcher : : Slot ( )
[
SNew ( SHorizontalBox )
+ SHorizontalBox : : Slot ( )
. VAlign ( VAlign_Center )
. AutoWidth ( )
[
SNew ( SImage )
. Image ( FEditorStyle : : GetBrush ( " GenericLock " ) )
]
+ SHorizontalBox : : Slot ( )
. VAlign ( VAlign_Center )
. Padding ( FMargin ( 8.0f , 0.0f ) )
. AutoWidth ( )
[
SNew ( STextBlock )
. Text ( LOCTEXT ( " DeviceProfileEditorSCCLockedLabel " , " The default device profile configuration is under Source Control. This file is currently locked. " ) )
]
+ SHorizontalBox : : Slot ( )
. HAlign ( HAlign_Right )
[
SNew ( SButton )
. OnClicked ( this , & SDeviceProfileSourceControl : : HandleCheckoutButtonPressed )
. IsEnabled ( this , & SDeviceProfileSourceControl : : IsCheckOutAvailable )
. Text ( LOCTEXT ( " CheckOutButtonText " , " Check Out File " ) )
]
]
]
]
] ;
}
---- 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
void SDeviceProfileSourceControl : : Tick ( const FGeometry & AllottedGeometry , const double InCurrentTime , const float InDeltaTime )
2014-04-02 18:09:23 -04:00
{
// cache selected settings object's configuration file state
---- 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
if ( InCurrentTime - LastDefaultConfigCheckOutTime > = 1.0f )
2014-04-02 18:09:23 -04:00
{
bIsDefaultConfigCheckOutNeeded = ( FPaths : : FileExists ( AbsoluteConfigFilePath ) & & IFileManager : : Get ( ) . IsReadOnly ( * AbsoluteConfigFilePath ) ) ;
---- 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
LastDefaultConfigCheckOutTime = InCurrentTime ;
2014-04-02 18:09:23 -04:00
}
}
2014-03-14 14:13:41 -04:00
void SDeviceProfileEditor : : Construct ( const FArguments & InArgs )
{
2015-03-17 09:50:32 -04:00
DeviceProfileManager = & UDeviceProfileManager : : Get ( ) ;
2014-03-14 14:13:41 -04:00
// Setup the tab layout for the editor.
TSharedRef < FWorkspaceItem > RootMenuGroup = FWorkspaceItem : : NewGroup ( LOCTEXT ( " RootMenuGroupName " , " Root " ) ) ;
2014-04-02 18:09:23 -04:00
DeviceManagerMenuGroup = RootMenuGroup - > AddGroup ( LOCTEXT ( " DeviceProfileEditorMenuGroupName " , " Device Profile Editor Tabs " ) ) ;
2014-03-14 14:13:41 -04:00
{
TSharedRef < SDockTab > DeviceProfilePropertyEditorTab =
SNew ( SDockTab )
. TabRole ( ETabRole : : MajorTab )
. Label ( LOCTEXT ( " TabTitle " , " Device Profile Editor " ) )
. ToolTipText ( LOCTEXT ( " TabTitle_ToolTip " , " The Device Profile Editor " ) ) ;
TabManager = FGlobalTabmanager : : Get ( ) - > NewTabManager ( DeviceProfilePropertyEditorTab ) ;
TabManager - > RegisterTabSpawner ( DeviceProfileEditorTabName , FOnSpawnTab : : CreateRaw ( this , & SDeviceProfileEditor : : HandleTabManagerSpawnTab , DeviceProfileEditorTabName ) )
2014-04-02 18:09:23 -04:00
. SetDisplayName ( LOCTEXT ( " DeviceProfilePropertyEditorLabel " , " Device Profile Property Editor... " ) )
. SetIcon ( FSlateIcon ( FEditorStyle : : GetStyleSetName ( ) , " DeviceDetails.Tabs.ProfileEditor " ) )
. SetGroup ( DeviceManagerMenuGroup . ToSharedRef ( ) ) ;
2014-03-14 14:13:41 -04:00
}
2014-04-02 18:09:23 -04:00
EditorTabStack = FTabManager : : NewStack ( )
- > AddTab ( DeviceProfileEditorTabName , ETabState : : OpenedTab )
- > SetHideTabWell ( true )
- > SetForegroundTab ( DeviceProfileEditorTabName ) ;
2014-03-14 14:13:41 -04:00
// Create the tab layout widget
const TSharedRef < FTabManager : : FLayout > Layout = FTabManager : : NewLayout ( " DeviceProfileEditorLayout_v2.0 " )
- > AddArea
(
FTabManager : : NewPrimaryArea ( )
- > SetOrientation ( Orient_Horizontal )
- > Split
(
2014-04-02 18:09:23 -04:00
EditorTabStack . ToSharedRef ( )
2014-03-14 14:13:41 -04:00
)
) ;
// Create & initialize main menu
FMenuBarBuilder MenuBarBuilder = FMenuBarBuilder ( TSharedPtr < FUICommandList > ( ) ) ;
MenuBarBuilder . AddPullDownMenu (
LOCTEXT ( " WindowMenuLabel " , " Window " ) ,
FText : : GetEmpty ( ) ,
FNewMenuDelegate : : CreateSP ( TabManager . ToSharedRef ( ) , & FTabManager : : PopulateTabSpawnerMenu , RootMenuGroup )
) ;
ChildSlot
[
2014-04-02 18:09:23 -04:00
// Create tab well where our property grid etc. will live
SNew ( SSplitter )
+ SSplitter : : Slot ( )
. Value ( 0.3f )
2014-03-14 14:13:41 -04:00
[
2014-04-02 18:09:23 -04:00
CreateMainDeviceProfilePanel ( ) . ToSharedRef ( )
2014-03-14 14:13:41 -04:00
]
2014-04-02 18:09:23 -04:00
+ SSplitter : : Slot ( )
. Value ( 0.7f )
2014-03-14 14:13:41 -04:00
[
2014-04-02 18:09:23 -04:00
SNew ( SVerticalBox )
2014-03-14 14:13:41 -04:00
+ SVerticalBox : : Slot ( )
2014-04-02 18:09:23 -04:00
. AutoHeight ( )
2014-03-14 14:13:41 -04:00
[
2014-04-02 18:09:23 -04:00
SNew ( SDeviceProfileSourceControl )
]
+ SVerticalBox : : Slot ( )
. Padding ( FMargin ( 0.0f , 2.0f ) )
. AutoHeight ( )
[
MenuBarBuilder . MakeWidget ( )
]
+ SVerticalBox : : Slot ( )
[
TabManager - > RestoreFrom ( Layout , TSharedPtr < SWindow > ( ) ) . ToSharedRef ( )
2014-03-14 14:13:41 -04:00
]
]
] ;
}
SDeviceProfileEditor : : ~ SDeviceProfileEditor ( )
{
if ( DeviceProfileManager . IsValid ( ) )
{
DeviceProfileManager - > SaveProfiles ( ) ;
}
2014-04-02 18:09:23 -04:00
if ( TabManager . IsValid ( ) )
{
TabManager - > CloseAllAreas ( ) ;
}
2014-03-14 14:13:41 -04:00
}
TSharedPtr < SWidget > SDeviceProfileEditor : : CreateMainDeviceProfilePanel ( )
{
2014-04-02 18:09:23 -04:00
TSharedPtr < SWidget > PanelWidget = SNew ( SSplitter )
2014-03-14 14:13:41 -04:00
. Orientation ( Orient_Vertical )
+ SSplitter : : Slot ( )
2014-04-02 18:09:23 -04:00
. Value ( 1.0f )
[
SNew ( SBorder )
. BorderImage ( FEditorStyle : : GetBrush ( " Docking.Tab.ContentAreaBrush " ) )
[
SAssignNew ( DeviceProfileSelectionPanel , SDeviceProfileSelectionPanel , DeviceProfileManager )
. OnDeviceProfilePinned ( this , & SDeviceProfileEditor : : HandleDeviceProfilePinned )
. OnDeviceProfileUnpinned ( this , & SDeviceProfileEditor : : HandleDeviceProfileUnpinned )
. OnDeviceProfileViewAlone ( this , & SDeviceProfileEditor : : HandleDeviceProfileViewAlone )
]
]
+ SSplitter : : Slot ( )
2014-03-14 14:13:41 -04:00
. SizeRule ( SSplitter : : ESizeRule : : SizeToContent )
[
2014-04-02 18:09:23 -04:00
SNew ( SBorder )
. BorderImage ( FEditorStyle : : GetBrush ( " Docking.Tab.ContentAreaBrush " ) )
2014-03-14 14:13:41 -04:00
[
2014-04-02 18:09:23 -04:00
SNew ( SDeviceProfileCreateProfilePanel , DeviceProfileManager )
2014-03-14 14:13:41 -04:00
]
2014-04-02 18:09:23 -04:00
] ;
2014-03-14 14:13:41 -04:00
return PanelWidget ;
}
TSharedRef < SDockTab > SDeviceProfileEditor : : HandleTabManagerSpawnTab ( const FSpawnTabArgs & Args , FName TabIdentifier )
{
TSharedPtr < SWidget > TabWidget = SNullWidget : : NullWidget ;
if ( TabIdentifier = = DeviceProfileEditorTabName )
{
2014-04-02 18:09:23 -04:00
TabWidget = SNew ( SBorder )
. BorderImage ( FEditorStyle : : GetBrush ( " ToolBar.Background " ) )
2014-03-14 14:13:41 -04:00
[
2014-04-02 18:09:23 -04:00
SNew ( SOverlay )
+ SOverlay : : Slot ( )
2014-03-14 14:13:41 -04:00
[
2014-04-02 18:09:23 -04:00
// Show the property editor
SNew ( SHorizontalBox )
+ SHorizontalBox : : Slot ( )
. FillWidth ( 0.375f )
2014-03-14 14:13:41 -04:00
[
2014-04-02 18:09:23 -04:00
SNew ( SBorder )
. Padding ( 2 )
. Content ( )
2014-03-14 14:13:41 -04:00
[
2014-04-02 18:09:23 -04:00
SetupPropertyEditor ( )
2014-03-14 14:13:41 -04:00
]
]
2014-04-02 18:09:23 -04:00
]
+ SOverlay : : Slot ( )
[
// Conditionally draw a notification that indicates profiles should be pinned to be visible.
SNew ( SVerticalBox )
. Visibility ( this , & SDeviceProfileEditor : : GetEmptyDeviceProfileGridNotificationVisibility )
2014-03-14 14:13:41 -04:00
+ SVerticalBox : : Slot ( )
[
2014-04-02 18:09:23 -04:00
SNew ( SBorder )
. BorderImage ( FEditorStyle : : GetBrush ( " ToolBar.Background " ) )
2014-03-14 14:13:41 -04:00
[
2014-04-02 18:09:23 -04:00
SNew ( SHorizontalBox )
+ SHorizontalBox : : Slot ( )
. AutoWidth ( )
. HAlign ( HAlign_Center )
. VAlign ( VAlign_Center )
2014-03-14 14:13:41 -04:00
[
2014-04-02 18:09:23 -04:00
SNew ( SImage )
. Image ( FEditorStyle : : GetBrush ( " PropertyEditor.AddColumnOverlay " ) )
2014-03-14 14:13:41 -04:00
]
2014-04-02 18:09:23 -04:00
+ SHorizontalBox : : Slot ( )
. AutoWidth ( )
. HAlign ( HAlign_Center )
. VAlign ( VAlign_Center )
2014-03-14 14:13:41 -04:00
[
2014-04-02 18:09:23 -04:00
SNew ( SImage )
. Image ( FEditorStyle : : GetBrush ( " PropertyEditor.RemoveColumn " ) )
]
2014-03-14 14:13:41 -04:00
2014-04-02 18:09:23 -04:00
+ SHorizontalBox : : Slot ( )
. AutoWidth ( )
. HAlign ( HAlign_Center )
. VAlign ( VAlign_Center )
. Padding ( FMargin ( 0 , 0 , 3 , 0 ) )
[
SNew ( STextBlock )
. Font ( FEditorStyle : : GetFontStyle ( " PropertyEditor.AddColumnMessage.Font " ) )
. Text ( LOCTEXT ( " GenericPropertiesTitle " , " Pin Profiles to Add Columns " ) )
. ColorAndOpacity ( FEditorStyle : : GetColor ( " PropertyEditor.AddColumnMessage.Color " ) )
2014-03-14 14:13:41 -04:00
]
]
]
]
2014-04-02 18:09:23 -04:00
] ;
2014-03-14 14:13:41 -04:00
}
// Return the tab with the relevant widget embedded
return SNew ( SDockTab )
. TabRole ( ETabRole : : PanelTab )
[
TabWidget . ToSharedRef ( )
] ;
}
2014-04-02 18:09:23 -04:00
TSharedRef < SDockTab > SDeviceProfileEditor : : HandleTabManagerSpawnSingleProfileTab ( const FSpawnTabArgs & Args , TWeakObjectPtr < UDeviceProfile > InDeviceProfile )
2014-03-14 14:13:41 -04:00
{
2014-04-02 18:09:23 -04:00
TSharedPtr < SWidget > TabWidget = SNullWidget : : NullWidget ;
TabWidget = SNew ( SVerticalBox )
+ SVerticalBox : : Slot ( )
[
SNew ( SDeviceProfileEditorSingleProfileView , InDeviceProfile )
] ;
TSharedPtr < SDockTab > Tab = SNew ( SDockTab )
. TabRole ( ETabRole : : PanelTab )
[
TabWidget . ToSharedRef ( )
] ;
// Return the tab with the relevant widget embedded
return Tab . ToSharedRef ( ) ;
2014-03-14 14:13:41 -04:00
}
2014-04-02 18:09:23 -04:00
void SDeviceProfileEditor : : HandleDeviceProfilePinned ( const TWeakObjectPtr < UDeviceProfile > & DeviceProfile )
2014-03-14 14:13:41 -04:00
{
if ( ! DeviceProfiles . Contains ( DeviceProfile . Get ( ) ) )
{
DeviceProfiles . Add ( DeviceProfile . Get ( ) ) ;
RebuildPropertyTable ( ) ;
2014-04-02 18:09:23 -04:00
TabManager - > InvokeTab ( DeviceProfileEditorTabName ) ;
2014-03-14 14:13:41 -04:00
}
}
2014-04-02 18:09:23 -04:00
void SDeviceProfileEditor : : HandleDeviceProfileUnpinned ( const TWeakObjectPtr < UDeviceProfile > & DeviceProfile )
2014-03-14 14:13:41 -04:00
{
if ( DeviceProfiles . Contains ( DeviceProfile . Get ( ) ) )
{
DeviceProfiles . Remove ( DeviceProfile . Get ( ) ) ;
RebuildPropertyTable ( ) ;
2014-04-02 18:09:23 -04:00
TabManager - > InvokeTab ( DeviceProfileEditorTabName ) ;
2014-03-14 14:13:41 -04:00
}
}
2014-04-02 18:09:23 -04:00
void SDeviceProfileEditor : : HandleDeviceProfileViewAlone ( const TWeakObjectPtr < UDeviceProfile > & DeviceProfile )
{
FName TabId = DeviceProfile - > GetFName ( ) ;
if ( ! RegisteredTabIds . Contains ( TabId ) )
{
RegisteredTabIds . Add ( TabId ) ;
TabManager - > RegisterTabSpawner ( TabId , FOnSpawnTab : : CreateRaw ( this , & SDeviceProfileEditor : : HandleTabManagerSpawnSingleProfileTab , DeviceProfile ) )
. SetDisplayName ( FText : : FromName ( TabId ) )
. SetIcon ( FSlateIcon ( FEditorStyle : : GetStyleSetName ( ) , " DeviceDetails.Tabs.ProfileEditorSingleProfile " ) )
. SetGroup ( DeviceManagerMenuGroup . ToSharedRef ( ) ) ;
}
TabManager - > InvokeTab ( TabId ) ;
}
2014-03-14 14:13:41 -04:00
EVisibility SDeviceProfileEditor : : GetEmptyDeviceProfileGridNotificationVisibility ( ) const
{
// IF we aren't showing any items, our prompt should be visible
return PropertyTable - > GetRows ( ) . Num ( ) > 0 ? EVisibility : : Hidden : EVisibility : : Visible ;
}
TSharedRef < SWidget > SDeviceProfileEditor : : SetupPropertyEditor ( )
{
FPropertyEditorModule & PropertyEditorModule = FModuleManager : : LoadModuleChecked < FPropertyEditorModule > ( " PropertyEditor " ) ;
PropertyTable = PropertyEditorModule . CreatePropertyTable ( ) ;
RebuildPropertyTable ( ) ;
2014-04-02 18:09:23 -04:00
// Adapt the CVars column as a button to open a single editor which will allow better control of the Console Variables
TSharedRef < FDeviceProfileConsoleVariableColumn > CVarsColumn = MakeShareable ( new FDeviceProfileConsoleVariableColumn ( ) ) ;
// Bind our action to open a single editor when requested from the property table
CVarsColumn - > OnEditCVarsRequest ( ) . BindRaw ( this , & SDeviceProfileEditor : : HandleDeviceProfileViewAlone ) ;
2015-03-17 09:50:32 -04:00
// Adapt the TextureLODSettings column as a button to open a single editor which will allow better control of the Texture Groups
TSharedRef < FDeviceProfileTextureLODSettingsColumn > TextureLODSettingsColumn = MakeShareable ( new FDeviceProfileTextureLODSettingsColumn ( ) ) ;
TextureLODSettingsColumn - > OnEditTextureLODSettingsRequest ( ) . BindRaw ( this , & SDeviceProfileEditor : : HandleDeviceProfileViewAlone ) ;
2014-04-02 18:09:23 -04:00
// Add our Custom Rows to the table
TArray < TSharedRef < IPropertyTableCustomColumn > > CustomColumns ;
CustomColumns . Add ( CVarsColumn ) ;
2015-03-17 09:50:32 -04:00
CustomColumns . Add ( TextureLODSettingsColumn ) ;
2014-04-02 18:09:23 -04:00
return PropertyEditorModule . CreatePropertyTableWidget ( PropertyTable . ToSharedRef ( ) , CustomColumns ) ;
2014-03-14 14:13:41 -04:00
}
2014-04-02 18:09:23 -04:00
2014-03-14 14:13:41 -04:00
void SDeviceProfileEditor : : RebuildPropertyTable ( )
{
PropertyTable - > SetObjects ( DeviceProfiles ) ;
PropertyTable - > SetSelectionMode ( ESelectionMode : : None ) ;
PropertyTable - > SetIsUserAllowedToChangeRoot ( false ) ;
for ( TFieldIterator < UProperty > DeviceProfilePropertyIter ( UDeviceProfile : : StaticClass ( ) ) ; DeviceProfilePropertyIter ; + + DeviceProfilePropertyIter )
{
TWeakObjectPtr < UProperty > DeviceProfileProperty = * DeviceProfilePropertyIter ;
2014-04-02 18:09:23 -04:00
if ( DeviceProfileProperty - > GetName ( ) ! = TEXT ( " Parent " ) )
{
PropertyTable - > AddColumn ( DeviceProfileProperty ) ;
}
2014-03-14 14:13:41 -04:00
}
PropertyTable - > RequestRefresh ( ) ;
}
2014-09-21 20:35:48 -04:00
# undef LOCTEXT_NAMESPACE
