1260 lines
30 KiB
C++
1260 lines
30 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "SequencerSettings.h"
|
|
#include "KeyParams.h"
|
|
#include "ISequencer.h"
|
|
#include "SSequencer.h"
|
|
#include "Misc/ConsoleVariables.h"
|
|
#include "MVVM/ViewModels/ViewDensity.h"
|
|
|
|
USequencerSettings::USequencerSettings( const FObjectInitializer& ObjectInitializer )
|
|
: Super( ObjectInitializer )
|
|
{
|
|
AutoChangeMode = EAutoChangeMode::None;
|
|
AllowEditsMode = EAllowEditsMode::AllEdits;
|
|
KeyGroupMode = EKeyGroupMode::KeyChanged;
|
|
KeyInterpolation = EMovieSceneKeyInterpolation::Auto;
|
|
bAutoSetTrackDefaults = false;
|
|
SpawnPosition = SSP_Origin;
|
|
bCreateSpawnableCameras = true;
|
|
bShowRangeSlider = false;
|
|
bIsSnapEnabled = true;
|
|
bSnapKeyTimesToElements = false;
|
|
bSnapSectionTimesToElements = false;
|
|
bSnapPlayTimeToKeys = false;
|
|
bSnapPlayTimeToSections = false;
|
|
bSnapPlayTimeToMarkers = false;
|
|
bSnapPlayTimeToPressedKey = true;
|
|
bSnapPlayTimeToDraggedKey = true;
|
|
bForceWholeFrames = true;
|
|
CurveValueSnapInterval = 0.1f;
|
|
GridSpacing = TOptional<float>();
|
|
bSnapCurveValueToInterval = false;
|
|
bShowSelectedNodesOnly = false;
|
|
ZoomPosition = ESequencerZoomPosition::SZP_CurrentTime;
|
|
bAutoScrollEnabled = false;
|
|
bLinkCurveEditorTimeRange = false;
|
|
bLinkFiltersWithCurveEditor = false;
|
|
bSynchronizeCurveEditorSelection = true;
|
|
bIsolateCurveEditorToSelection = true;
|
|
bCurveEditorVisible = false;
|
|
LoopMode = ESequencerLoopMode::SLM_NoLoop;
|
|
bSnapKeysAndSectionsToPlayRange = false;
|
|
bResetPlayheadWhenNavigating = false;
|
|
bKeepCursorInPlayRangeWhileScrubbing = false;
|
|
bKeepPlayRangeInSectionBounds = true;
|
|
bCompileDirectorOnEvaluate = true;
|
|
bLeftMouseDragDoesMarquee = false;
|
|
ZeroPadFrames = 0;
|
|
JumpFrameIncrement = FFrameNumber(5);
|
|
TimeWarpDisplay = ESequencerTimeWarpDisplay::Both;
|
|
bShowLayerBars = true;
|
|
bShowKeyBars = true;
|
|
bInfiniteKeyAreas = false;
|
|
bShowChannelColors = false;
|
|
bShowInfoButton = true;
|
|
ReduceKeysTolerance = KINDA_SMALL_NUMBER;
|
|
KeyAreaHeightWithCurves = SequencerLayoutConstants::KeyAreaHeight;
|
|
bDeleteKeysWhenTrimming = true;
|
|
bDisableSectionsAfterBaking = true;
|
|
PlaybackRangeStartColor = FLinearColor(0.1f, 0.5f, 0.1f, 1.0f);
|
|
PlaybackRangeEndColor = FLinearColor(0.5f, 0.01f, 0.01f, 1.0f);
|
|
MarkedFrameColor = FLinearColor(0.f, 1.f, 1.f, 0.4f);
|
|
bCleanPlaybackMode = true;
|
|
bActivateRealtimeViewports = true;
|
|
bEvaluateSubSequencesInIsolation = false;
|
|
bRerunConstructionScripts = true;
|
|
bVisualizePreAndPostRoll = true;
|
|
TrajectoryPathCap = 250;
|
|
FrameNumberDisplayFormat = EFrameNumberDisplayFormats::Seconds;
|
|
bAutoExpandNodesOnSelection = true;
|
|
bRestoreOriginalViewportOnCameraCutUnlock = true;
|
|
TreeViewWidth = 0.3f;
|
|
bShowTickLines = true;
|
|
bShowSequencerToolbar = true;
|
|
bShowMarkedFrames = true;
|
|
bShowScalingAnchors = true;
|
|
ViewDensity = "Relaxed";
|
|
AssetBrowserWidth = 500.f;
|
|
AssetBrowserHeight = 300.f;
|
|
bNavigationToolVisible = false;
|
|
|
|
SectionColorTints.Add(FColor(88, 102, 142, 255)); // blue
|
|
SectionColorTints.Add(FColor(99, 137, 132, 255)); // blue-green
|
|
SectionColorTints.Add(FColor(110, 127, 92, 255)); // green
|
|
SectionColorTints.Add(FColor(151, 142, 102, 255)); // yellow
|
|
SectionColorTints.Add(FColor(147, 119, 101, 255)); // orange
|
|
SectionColorTints.Add(FColor(139, 95, 108, 255)); // red
|
|
SectionColorTints.Add(FColor(109, 74, 121, 255)); // purple
|
|
|
|
// Positive x -> zooming out, Negative x -> zooming in. X is in seconds.
|
|
// Don't add any factors for zoom-in. Zoom-in is already very fast with a zoom factor of 1.
|
|
CurveEditorZoomScaling.HorizontalZoomScale.EditorCurveData.AddKey(100, 6); // ... e.g. showing 100 seconds worth of frames, zoom out factor is 6.
|
|
CurveEditorZoomScaling.VerticalZoomScale.EditorCurveData.AddKey(100, 6);
|
|
CurveEditorZoomScaling.bLimitHorizontalZoomOut = false;
|
|
CurveEditorZoomScaling.bLimitVerticalZoomOut = false;
|
|
CurveEditorZoomScaling.MaxHorizontalZoomOut = 900; // Cannot zoom out more than 900 seconds = 15 minutes.
|
|
CurveEditorZoomScaling.MaxVerticalZoomOut = 10000;
|
|
}
|
|
|
|
void USequencerSettings::PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent)
|
|
{
|
|
Super::PostEditChangeProperty(PropertyChangedEvent);
|
|
}
|
|
|
|
EAutoChangeMode USequencerSettings::GetAutoChangeMode() const
|
|
{
|
|
return AutoChangeMode;
|
|
}
|
|
|
|
void USequencerSettings::SetAutoChangeMode(EAutoChangeMode InAutoChangeMode)
|
|
{
|
|
if ( AutoChangeMode != InAutoChangeMode )
|
|
{
|
|
AutoChangeMode = InAutoChangeMode;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
EAllowEditsMode USequencerSettings::GetAllowEditsMode() const
|
|
{
|
|
return AllowEditsMode;
|
|
}
|
|
|
|
void USequencerSettings::SetAllowEditsMode(EAllowEditsMode InAllowEditsMode)
|
|
{
|
|
if ( AllowEditsMode != InAllowEditsMode )
|
|
{
|
|
AllowEditsMode = InAllowEditsMode;
|
|
SaveConfig();
|
|
|
|
OnAllowEditsModeChangedEvent.Broadcast(InAllowEditsMode);
|
|
}
|
|
}
|
|
|
|
EKeyGroupMode USequencerSettings::GetKeyGroupMode() const
|
|
{
|
|
return KeyGroupMode;
|
|
}
|
|
|
|
void USequencerSettings::SetKeyGroupMode(EKeyGroupMode InKeyGroupMode)
|
|
{
|
|
if (KeyGroupMode != InKeyGroupMode)
|
|
{
|
|
KeyGroupMode = InKeyGroupMode;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
EMovieSceneKeyInterpolation USequencerSettings::GetKeyInterpolation() const
|
|
{
|
|
return KeyInterpolation;
|
|
}
|
|
|
|
void USequencerSettings::SetKeyInterpolation(EMovieSceneKeyInterpolation InKeyInterpolation)
|
|
{
|
|
if ( KeyInterpolation != InKeyInterpolation)
|
|
{
|
|
KeyInterpolation = InKeyInterpolation;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
ESequencerSpawnPosition USequencerSettings::GetSpawnPosition() const
|
|
{
|
|
return SpawnPosition;
|
|
}
|
|
|
|
void USequencerSettings::SetSpawnPosition(ESequencerSpawnPosition InSpawnPosition)
|
|
{
|
|
if ( SpawnPosition != InSpawnPosition)
|
|
{
|
|
SpawnPosition = InSpawnPosition;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetCreateSpawnableCameras() const
|
|
{
|
|
return bCreateSpawnableCameras;
|
|
}
|
|
|
|
void USequencerSettings::SetCreateSpawnableCameras(bool bInCreateSpawnableCameras)
|
|
{
|
|
if ( bCreateSpawnableCameras != bInCreateSpawnableCameras)
|
|
{
|
|
bCreateSpawnableCameras = bInCreateSpawnableCameras;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetShowRangeSlider() const
|
|
{
|
|
return bShowRangeSlider;
|
|
}
|
|
|
|
void USequencerSettings::SetShowRangeSlider(bool InbShowRangeSlider)
|
|
{
|
|
if ( bShowRangeSlider != InbShowRangeSlider )
|
|
{
|
|
bShowRangeSlider = InbShowRangeSlider;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetIsSnapEnabled() const
|
|
{
|
|
return bIsSnapEnabled;
|
|
}
|
|
|
|
void USequencerSettings::SetIsSnapEnabled(bool InbIsSnapEnabled)
|
|
{
|
|
if ( bIsSnapEnabled != InbIsSnapEnabled )
|
|
{
|
|
bIsSnapEnabled = InbIsSnapEnabled;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetSnapKeyTimesToElements() const
|
|
{
|
|
return bSnapKeyTimesToElements;
|
|
}
|
|
|
|
void USequencerSettings::SetSnapKeyTimesToElements(bool InbSnapKeyTimesToElements)
|
|
{
|
|
if ( bSnapKeyTimesToElements != InbSnapKeyTimesToElements)
|
|
{
|
|
bSnapKeyTimesToElements = InbSnapKeyTimesToElements;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetLeftMouseDragDoesMarquee() const
|
|
{
|
|
return bLeftMouseDragDoesMarquee;
|
|
}
|
|
void USequencerSettings::SetLeftMouseDragDoesMarque(bool bDoMarque)
|
|
{
|
|
if (bLeftMouseDragDoesMarquee != bDoMarque)
|
|
{
|
|
bLeftMouseDragDoesMarquee = bDoMarque;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetSnapSectionTimesToElements() const
|
|
{
|
|
return bSnapSectionTimesToElements;
|
|
}
|
|
|
|
void USequencerSettings::SetSnapSectionTimesToElements( bool InbSnapSectionTimesToElements )
|
|
{
|
|
if (bSnapSectionTimesToElements != InbSnapSectionTimesToElements)
|
|
{
|
|
bSnapSectionTimesToElements = InbSnapSectionTimesToElements;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetSnapKeysAndSectionsToPlayRange() const
|
|
{
|
|
return bSnapKeysAndSectionsToPlayRange;
|
|
}
|
|
|
|
void USequencerSettings::SetSnapKeysAndSectionsToPlayRange(bool bInSnapKeysAndSectionsToPlayRange)
|
|
{
|
|
if (bSnapKeysAndSectionsToPlayRange != bInSnapKeysAndSectionsToPlayRange)
|
|
{
|
|
bSnapKeysAndSectionsToPlayRange = bInSnapKeysAndSectionsToPlayRange;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetSnapPlayTimeToKeys() const
|
|
{
|
|
return bSnapPlayTimeToKeys;
|
|
}
|
|
|
|
void USequencerSettings::SetSnapPlayTimeToKeys(bool InbSnapPlayTimeToKeys)
|
|
{
|
|
if ( bSnapPlayTimeToKeys != InbSnapPlayTimeToKeys )
|
|
{
|
|
bSnapPlayTimeToKeys = InbSnapPlayTimeToKeys;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetSnapPlayTimeToSections() const
|
|
{
|
|
return bSnapPlayTimeToSections;
|
|
}
|
|
|
|
void USequencerSettings::SetSnapPlayTimeToSections(bool InbSnapPlayTimeToSections)
|
|
{
|
|
if (bSnapPlayTimeToSections != InbSnapPlayTimeToSections)
|
|
{
|
|
bSnapPlayTimeToSections = InbSnapPlayTimeToSections;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetSnapPlayTimeToMarkers() const
|
|
{
|
|
return bSnapPlayTimeToMarkers;
|
|
}
|
|
|
|
void USequencerSettings::SetSnapPlayTimeToMarkers(bool InbSnapPlayTimeToMarkers)
|
|
{
|
|
if ( bSnapPlayTimeToMarkers != InbSnapPlayTimeToMarkers )
|
|
{
|
|
bSnapPlayTimeToMarkers = InbSnapPlayTimeToMarkers;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetSnapPlayTimeToPressedKey() const
|
|
{
|
|
return bSnapPlayTimeToPressedKey;
|
|
}
|
|
|
|
void USequencerSettings::SetSnapPlayTimeToPressedKey(bool InbSnapPlayTimeToPressedKey)
|
|
{
|
|
if ( bSnapPlayTimeToPressedKey != InbSnapPlayTimeToPressedKey )
|
|
{
|
|
bSnapPlayTimeToPressedKey = InbSnapPlayTimeToPressedKey;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetSnapPlayTimeToDraggedKey() const
|
|
{
|
|
return bSnapPlayTimeToDraggedKey;
|
|
}
|
|
|
|
void USequencerSettings::SetSnapPlayTimeToDraggedKey(bool InbSnapPlayTimeToDraggedKey)
|
|
{
|
|
if ( bSnapPlayTimeToDraggedKey != InbSnapPlayTimeToDraggedKey )
|
|
{
|
|
bSnapPlayTimeToDraggedKey = InbSnapPlayTimeToDraggedKey;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
float USequencerSettings::GetCurveValueSnapInterval() const
|
|
{
|
|
return CurveValueSnapInterval;
|
|
}
|
|
|
|
void USequencerSettings::SetCurveValueSnapInterval( float InCurveValueSnapInterval )
|
|
{
|
|
if ( CurveValueSnapInterval != InCurveValueSnapInterval )
|
|
{
|
|
CurveValueSnapInterval = InCurveValueSnapInterval;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
TOptional<float> USequencerSettings::GetGridSpacing() const
|
|
{
|
|
return GridSpacing;
|
|
}
|
|
|
|
void USequencerSettings::SetGridSpacing(TOptional<float> InGridSpacing)
|
|
{
|
|
if (InGridSpacing != GridSpacing)
|
|
{
|
|
GridSpacing = InGridSpacing;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetSnapCurveValueToInterval() const
|
|
{
|
|
return bSnapCurveValueToInterval;
|
|
}
|
|
|
|
void USequencerSettings::SetSnapCurveValueToInterval( bool InbSnapCurveValueToInterval )
|
|
{
|
|
if ( bSnapCurveValueToInterval != InbSnapCurveValueToInterval )
|
|
{
|
|
bSnapCurveValueToInterval = InbSnapCurveValueToInterval;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetForceWholeFrames() const
|
|
{
|
|
return bForceWholeFrames;
|
|
}
|
|
|
|
void USequencerSettings::SetForceWholeFrames(bool InbForceWholeFrames)
|
|
{
|
|
if (bForceWholeFrames != InbForceWholeFrames)
|
|
{
|
|
bForceWholeFrames = InbForceWholeFrames;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetShowSelectedNodesOnly() const
|
|
{
|
|
return bShowSelectedNodesOnly;
|
|
}
|
|
|
|
void USequencerSettings::SetShowSelectedNodesOnly(bool Visible)
|
|
{
|
|
if (bShowSelectedNodesOnly != Visible)
|
|
{
|
|
bShowSelectedNodesOnly = Visible;
|
|
SaveConfig();
|
|
|
|
OnShowSelectedNodesOnlyChangedEvent.Broadcast();
|
|
}
|
|
}
|
|
|
|
ESequencerZoomPosition USequencerSettings::GetZoomPosition() const
|
|
{
|
|
return ZoomPosition;
|
|
}
|
|
|
|
void USequencerSettings::SetZoomPosition(ESequencerZoomPosition InZoomPosition)
|
|
{
|
|
if ( ZoomPosition != InZoomPosition)
|
|
{
|
|
ZoomPosition = InZoomPosition;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetAutoScrollEnabled() const
|
|
{
|
|
return bAutoScrollEnabled;
|
|
}
|
|
|
|
void USequencerSettings::SetAutoScrollEnabled(bool bInAutoScrollEnabled)
|
|
{
|
|
if (bAutoScrollEnabled != bInAutoScrollEnabled)
|
|
{
|
|
bAutoScrollEnabled = bInAutoScrollEnabled;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
void USequencerSettings::SetCurveEditorZoomScaling(const FCurveEditorZoomScaleConfig& Value)
|
|
{
|
|
CurveEditorZoomScaling = Value;
|
|
SaveConfig();
|
|
}
|
|
|
|
ESequencerLoopMode USequencerSettings::GetLoopMode() const
|
|
{
|
|
return LoopMode;
|
|
}
|
|
|
|
void USequencerSettings::SetLoopMode(ESequencerLoopMode InLoopMode)
|
|
{
|
|
if (LoopMode != InLoopMode)
|
|
{
|
|
LoopMode = InLoopMode;
|
|
OnLoopStateChangedEvent.Broadcast();
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::ShouldResetPlayheadWhenNavigating() const
|
|
{
|
|
return bResetPlayheadWhenNavigating;
|
|
}
|
|
|
|
void USequencerSettings::SetResetPlayheadWhenNavigating(bool bInResetPlayheadWhenNavigating)
|
|
{
|
|
if (bResetPlayheadWhenNavigating != bInResetPlayheadWhenNavigating)
|
|
{
|
|
bResetPlayheadWhenNavigating = bInResetPlayheadWhenNavigating;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::ShouldKeepCursorInPlayRangeWhileScrubbing() const
|
|
{
|
|
return bKeepCursorInPlayRangeWhileScrubbing;
|
|
}
|
|
|
|
void USequencerSettings::SetKeepCursorInPlayRangeWhileScrubbing(bool bInKeepCursorInPlayRangeWhileScrubbing)
|
|
{
|
|
if (bKeepCursorInPlayRangeWhileScrubbing != bInKeepCursorInPlayRangeWhileScrubbing)
|
|
{
|
|
bKeepCursorInPlayRangeWhileScrubbing = bInKeepCursorInPlayRangeWhileScrubbing;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::ShouldKeepPlayRangeInSectionBounds() const
|
|
{
|
|
return bKeepPlayRangeInSectionBounds;
|
|
}
|
|
|
|
void USequencerSettings::SetKeepPlayRangeInSectionBounds(bool bInKeepPlayRangeInSectionBounds)
|
|
{
|
|
if (bKeepPlayRangeInSectionBounds != bInKeepPlayRangeInSectionBounds)
|
|
{
|
|
bKeepPlayRangeInSectionBounds = bInKeepPlayRangeInSectionBounds;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
|
|
bool USequencerSettings::GetLinkCurveEditorTimeRange() const
|
|
{
|
|
return bLinkCurveEditorTimeRange;
|
|
}
|
|
|
|
void USequencerSettings::SetLinkCurveEditorTimeRange(bool InbLinkCurveEditorTimeRange)
|
|
{
|
|
if (bLinkCurveEditorTimeRange != InbLinkCurveEditorTimeRange)
|
|
{
|
|
bLinkCurveEditorTimeRange = InbLinkCurveEditorTimeRange;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetLinkFiltersWithCurveEditor() const
|
|
{
|
|
return bLinkFiltersWithCurveEditor;
|
|
}
|
|
|
|
void USequencerSettings::SetLinkFiltersWithCurveEditor(bool bInLinkFiltersWithCurveEditor)
|
|
{
|
|
if (bLinkFiltersWithCurveEditor != bInLinkFiltersWithCurveEditor)
|
|
{
|
|
bLinkFiltersWithCurveEditor = bInLinkFiltersWithCurveEditor;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
void USequencerSettings::SyncCurveEditorSelection(bool bInSynchronizeCurveEditorSelection)
|
|
{
|
|
if (bSynchronizeCurveEditorSelection != bInSynchronizeCurveEditorSelection)
|
|
{
|
|
bSynchronizeCurveEditorSelection = bInSynchronizeCurveEditorSelection;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
void USequencerSettings::IsolateCurveEditorToSelection(bool bInIsolateCurveEditorToSelection)
|
|
{
|
|
if (bIsolateCurveEditorToSelection != bInIsolateCurveEditorToSelection)
|
|
{
|
|
bIsolateCurveEditorToSelection = bInIsolateCurveEditorToSelection;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
void USequencerSettings::SetCurveEditorVisible(bool bInCurveEditorVisible)
|
|
{
|
|
if (bCurveEditorVisible != bInCurveEditorVisible)
|
|
{
|
|
bCurveEditorVisible = bInCurveEditorVisible;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
uint8 USequencerSettings::GetZeroPadFrames() const
|
|
{
|
|
return ZeroPadFrames;
|
|
}
|
|
|
|
void USequencerSettings::SetZeroPadFrames(uint8 InZeroPadFrames)
|
|
{
|
|
if (ZeroPadFrames != InZeroPadFrames)
|
|
{
|
|
ZeroPadFrames = InZeroPadFrames;
|
|
SaveConfig();
|
|
OnTimeDisplayFormatChangedEvent.Broadcast();
|
|
}
|
|
}
|
|
|
|
FFrameNumber USequencerSettings::GetJumpFrameIncrement() const
|
|
{
|
|
return JumpFrameIncrement;
|
|
}
|
|
|
|
void USequencerSettings::SetJumpFrameIncrement(FFrameNumber InJumpFrameIncrement)
|
|
{
|
|
if (JumpFrameIncrement != InJumpFrameIncrement)
|
|
{
|
|
JumpFrameIncrement = InJumpFrameIncrement;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
ESequencerTimeWarpDisplay USequencerSettings::GetTimeWarpDisplayMode() const
|
|
{
|
|
return TimeWarpDisplay;
|
|
}
|
|
|
|
void USequencerSettings::SetTimeWarpDisplayMode(ESequencerTimeWarpDisplay InTimeWarpDisplay)
|
|
{
|
|
if (TimeWarpDisplay != InTimeWarpDisplay)
|
|
{
|
|
TimeWarpDisplay = InTimeWarpDisplay;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetShowLayerBars() const
|
|
{
|
|
return bShowLayerBars;
|
|
}
|
|
|
|
void USequencerSettings::SetShowLayerBars(bool InbShowLayerBars)
|
|
{
|
|
if (bShowLayerBars != InbShowLayerBars)
|
|
{
|
|
bShowLayerBars = InbShowLayerBars;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetShowKeyBars() const
|
|
{
|
|
return bShowKeyBars;
|
|
}
|
|
|
|
void USequencerSettings::SetShowKeyBars(bool InbShowKeyBars)
|
|
{
|
|
if (bShowKeyBars != InbShowKeyBars)
|
|
{
|
|
bShowKeyBars = InbShowKeyBars;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetInfiniteKeyAreas() const
|
|
{
|
|
return bInfiniteKeyAreas;
|
|
}
|
|
|
|
void USequencerSettings::SetInfiniteKeyAreas(bool InbInfiniteKeyAreas)
|
|
{
|
|
if (bInfiniteKeyAreas != InbInfiniteKeyAreas)
|
|
{
|
|
bInfiniteKeyAreas = InbInfiniteKeyAreas;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
|
|
bool USequencerSettings::GetShowChannelColors() const
|
|
{
|
|
return bShowChannelColors;
|
|
}
|
|
|
|
void USequencerSettings::SetShowChannelColors(bool InbShowChannelColors)
|
|
{
|
|
if (bShowChannelColors != InbShowChannelColors)
|
|
{
|
|
bShowChannelColors = InbShowChannelColors;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetShowInfoButton() const
|
|
{
|
|
return bShowInfoButton;
|
|
}
|
|
|
|
void USequencerSettings::SetShowInfoButton(bool InbShowInfoButton)
|
|
{
|
|
if (bShowInfoButton != InbShowInfoButton)
|
|
{
|
|
bShowInfoButton = InbShowInfoButton;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetShowTickLines() const
|
|
{
|
|
return bShowTickLines;
|
|
}
|
|
|
|
void USequencerSettings::SetShowTickLines(bool bInDrawTickLines)
|
|
{
|
|
if(bShowTickLines != bInDrawTickLines)
|
|
{
|
|
bShowTickLines = bInDrawTickLines;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetShowSequencerToolbar() const
|
|
{
|
|
return bShowSequencerToolbar;
|
|
}
|
|
|
|
void USequencerSettings::SetShowSequencerToolbar(bool bInShowSequencerToolbar)
|
|
{
|
|
if(bShowSequencerToolbar != bInShowSequencerToolbar)
|
|
{
|
|
bShowSequencerToolbar = bInShowSequencerToolbar;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetShowMarkedFrames() const
|
|
{
|
|
return bShowMarkedFrames;
|
|
}
|
|
|
|
void USequencerSettings::SetShowMarkedFrames(bool bInShowMarkedFrames)
|
|
{
|
|
if (bShowMarkedFrames != bInShowMarkedFrames)
|
|
{
|
|
bShowMarkedFrames = bInShowMarkedFrames;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetShowScalingAnchors() const
|
|
{
|
|
return bShowScalingAnchors;
|
|
}
|
|
|
|
void USequencerSettings::SetShowScalingAnchors(bool bInShowScalingAnchors)
|
|
{
|
|
if (bShowScalingAnchors != bInShowScalingAnchors)
|
|
{
|
|
bShowScalingAnchors = bInShowScalingAnchors;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::HasKeyAreaCurveExtents(const FString& ChannelName) const
|
|
{
|
|
TArray<FString> ChannelsArray;
|
|
KeyAreaCurveExtents.ParseIntoArray(ChannelsArray, TEXT(":"));
|
|
|
|
for (int32 ChannelIndex = 0; ChannelIndex < ChannelsArray.Num(); ++ChannelIndex)
|
|
{
|
|
TArray<FString> ExtentsArray;
|
|
ChannelsArray[ChannelIndex].ParseIntoArray(ExtentsArray, TEXT(","));
|
|
|
|
if (ExtentsArray.Num() == 3 && ExtentsArray[0] == ChannelName)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void USequencerSettings::RemoveKeyAreaCurveExtents(const FString& ChannelName)
|
|
{
|
|
TArray<FString> ChannelsArray;
|
|
KeyAreaCurveExtents.ParseIntoArray(ChannelsArray, TEXT(":"));
|
|
|
|
FString NewKeyAreaCurveExtents;
|
|
for (int32 ChannelIndex = 0; ChannelIndex < ChannelsArray.Num(); ++ChannelIndex)
|
|
{
|
|
TArray<FString> ExtentsArray;
|
|
ChannelsArray[ChannelIndex].ParseIntoArray(ExtentsArray, TEXT(","));
|
|
|
|
if (ExtentsArray.Num() == 3 && ExtentsArray[0] == ChannelName)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
NewKeyAreaCurveExtents.Append(TEXT(":"));
|
|
NewKeyAreaCurveExtents.Append(ChannelsArray[ChannelIndex]);
|
|
}
|
|
|
|
KeyAreaCurveExtents = NewKeyAreaCurveExtents;
|
|
SaveConfig();
|
|
}
|
|
|
|
void USequencerSettings::SetKeyAreaCurveExtents(const FString& ChannelName, double InMin, double InMax)
|
|
{
|
|
RemoveKeyAreaCurveExtents(ChannelName);
|
|
|
|
FString NewChannelExtents = FString::Printf(TEXT("%s,%0.3f,%0.3f"), *ChannelName, InMin, InMax);
|
|
KeyAreaCurveExtents.Append(TEXT(":"));
|
|
KeyAreaCurveExtents.Append(NewChannelExtents);
|
|
|
|
SaveConfig();
|
|
}
|
|
|
|
void USequencerSettings::GetKeyAreaCurveExtents(const FString& ChannelName, double& OutMin, double& OutMax) const
|
|
{
|
|
TArray<FString> ChannelsArray;
|
|
KeyAreaCurveExtents.ParseIntoArray(ChannelsArray, TEXT(":"));
|
|
|
|
for (int32 ChannelIndex = 0; ChannelIndex < ChannelsArray.Num(); ++ChannelIndex)
|
|
{
|
|
TArray<FString> ExtentsArray;
|
|
ChannelsArray[ChannelIndex].ParseIntoArray(ExtentsArray, TEXT(","));
|
|
|
|
if (ExtentsArray.Num() == 3 && ExtentsArray[0] == ChannelName)
|
|
{
|
|
OutMin = FCString::Atod(*ExtentsArray[1]);
|
|
OutMax = FCString::Atod(*ExtentsArray[2]);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
float USequencerSettings::GetKeyAreaHeightWithCurves() const
|
|
{
|
|
return KeyAreaHeightWithCurves;
|
|
}
|
|
|
|
void USequencerSettings::SetKeyAreaHeightWithCurves(float InKeyAreaHeightWithCurves)
|
|
{
|
|
if (KeyAreaHeightWithCurves != InKeyAreaHeightWithCurves)
|
|
{
|
|
KeyAreaHeightWithCurves = InKeyAreaHeightWithCurves;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
float USequencerSettings::GetReduceKeysTolerance() const
|
|
{
|
|
return ReduceKeysTolerance;
|
|
}
|
|
|
|
void USequencerSettings::SetReduceKeysTolerance(float InReduceKeysTolerance)
|
|
{
|
|
if (ReduceKeysTolerance != InReduceKeysTolerance)
|
|
{
|
|
ReduceKeysTolerance = InReduceKeysTolerance;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetDeleteKeysWhenTrimming() const
|
|
{
|
|
return bDeleteKeysWhenTrimming;
|
|
}
|
|
|
|
void USequencerSettings::SetDeleteKeysWhenTrimming(bool bInDeleteKeysWhenTrimming)
|
|
{
|
|
if (bDeleteKeysWhenTrimming != bInDeleteKeysWhenTrimming)
|
|
{
|
|
bDeleteKeysWhenTrimming = bInDeleteKeysWhenTrimming;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetDisableSectionsAfterBaking() const
|
|
{
|
|
return bDisableSectionsAfterBaking;
|
|
}
|
|
|
|
void USequencerSettings::SetDisableSectionsAfterBaking(bool bInDisableSectionsAfterBaking)
|
|
{
|
|
if (bDisableSectionsAfterBaking != bInDisableSectionsAfterBaking)
|
|
{
|
|
bDisableSectionsAfterBaking = bInDisableSectionsAfterBaking;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
FLinearColor USequencerSettings::GetPlaybackRangeStartColor() const
|
|
{
|
|
return PlaybackRangeStartColor;
|
|
}
|
|
|
|
void USequencerSettings::SetPlaybackRangeStartColor(const FLinearColor& InPlaybackRangeStartColor)
|
|
{
|
|
if (PlaybackRangeStartColor != InPlaybackRangeStartColor)
|
|
{
|
|
PlaybackRangeStartColor = InPlaybackRangeStartColor;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
FLinearColor USequencerSettings::GetPlaybackRangeEndColor() const
|
|
{
|
|
return PlaybackRangeEndColor;
|
|
}
|
|
|
|
void USequencerSettings::SetPlaybackRangeEndColor(const FLinearColor& InPlaybackRangeEndColor)
|
|
{
|
|
if (PlaybackRangeEndColor != InPlaybackRangeEndColor)
|
|
{
|
|
PlaybackRangeEndColor = InPlaybackRangeEndColor;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
FLinearColor USequencerSettings::GetMarkedFrameColor() const
|
|
{
|
|
return MarkedFrameColor;
|
|
}
|
|
|
|
void USequencerSettings::SetMarkedFrameColor(const FLinearColor& InMarkedFrameColor)
|
|
{
|
|
if (MarkedFrameColor != InMarkedFrameColor)
|
|
{
|
|
MarkedFrameColor = InMarkedFrameColor;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
TArray<FColor> USequencerSettings::GetSectionColorTints() const
|
|
{
|
|
return SectionColorTints;
|
|
}
|
|
|
|
void USequencerSettings::SetSectionColorTints(const TArray<FColor>& InSectionColorTints)
|
|
{
|
|
if (SectionColorTints != InSectionColorTints)
|
|
{
|
|
SectionColorTints = InSectionColorTints;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetCleanPlaybackMode() const
|
|
{
|
|
return bCleanPlaybackMode;
|
|
}
|
|
|
|
void USequencerSettings::SetCleanPlaybackMode(bool bInCleanPlaybackMode)
|
|
{
|
|
if (bInCleanPlaybackMode != bCleanPlaybackMode)
|
|
{
|
|
bCleanPlaybackMode = bInCleanPlaybackMode;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::ShouldActivateRealtimeViewports() const
|
|
{
|
|
return bActivateRealtimeViewports;
|
|
}
|
|
|
|
void USequencerSettings::SetActivateRealtimeViewports(bool bInActivateRealtimeViewports)
|
|
{
|
|
if (bInActivateRealtimeViewports != bActivateRealtimeViewports)
|
|
{
|
|
bActivateRealtimeViewports = bInActivateRealtimeViewports;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::GetAutoSetTrackDefaults() const
|
|
{
|
|
return bAutoSetTrackDefaults;
|
|
}
|
|
|
|
void USequencerSettings::SetAutoSetTrackDefaults(bool bInAutoSetTrackDefaults)
|
|
{
|
|
if (bInAutoSetTrackDefaults != bAutoSetTrackDefaults)
|
|
{
|
|
bAutoSetTrackDefaults = bInAutoSetTrackDefaults;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::ShouldShowDebugVisualization() const
|
|
{
|
|
return bShowDebugVisualization;
|
|
}
|
|
|
|
void USequencerSettings::SetShowDebugVisualization(bool bInShowDebugVisualization)
|
|
{
|
|
if (bShowDebugVisualization != bInShowDebugVisualization)
|
|
{
|
|
bShowDebugVisualization = bInShowDebugVisualization;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::ShouldEvaluateSubSequencesInIsolation() const
|
|
{
|
|
return bEvaluateSubSequencesInIsolation;
|
|
}
|
|
|
|
void USequencerSettings::SetEvaluateSubSequencesInIsolation(bool bInEvaluateSubSequencesInIsolation)
|
|
{
|
|
if (bEvaluateSubSequencesInIsolation != bInEvaluateSubSequencesInIsolation)
|
|
{
|
|
bEvaluateSubSequencesInIsolation = bInEvaluateSubSequencesInIsolation;
|
|
SaveConfig();
|
|
|
|
OnEvaluateSubSequencesInIsolationChangedEvent.Broadcast();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::ShouldRerunConstructionScripts() const
|
|
{
|
|
return bRerunConstructionScripts;
|
|
}
|
|
|
|
void USequencerSettings::SetRerunConstructionScripts(bool bInRerunConstructionScripts)
|
|
{
|
|
if (bRerunConstructionScripts != bInRerunConstructionScripts)
|
|
{
|
|
bRerunConstructionScripts = bInRerunConstructionScripts;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
bool USequencerSettings::ShouldShowPrePostRoll() const
|
|
{
|
|
return bVisualizePreAndPostRoll;
|
|
}
|
|
|
|
void USequencerSettings::SetShouldShowPrePostRoll(bool bInVisualizePreAndPostRoll)
|
|
{
|
|
if (bInVisualizePreAndPostRoll != bVisualizePreAndPostRoll)
|
|
{
|
|
bVisualizePreAndPostRoll = bInVisualizePreAndPostRoll;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
|
|
bool USequencerSettings::ShouldCompileDirectorOnEvaluate() const
|
|
{
|
|
return bCompileDirectorOnEvaluate;
|
|
}
|
|
|
|
void USequencerSettings::SetCompileDirectorOnEvaluate(bool bInCompileDirectorOnEvaluate)
|
|
{
|
|
if (bInCompileDirectorOnEvaluate != bCompileDirectorOnEvaluate)
|
|
{
|
|
bCompileDirectorOnEvaluate = bInCompileDirectorOnEvaluate;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
USequencerSettings::FOnLoopStateChanged& USequencerSettings::GetOnLoopStateChanged()
|
|
{
|
|
return OnLoopStateChangedEvent;
|
|
}
|
|
|
|
USequencerSettings::FOnTimeDisplayFormatChanged& USequencerSettings::GetOnTimeDisplayFormatChanged()
|
|
{
|
|
return OnTimeDisplayFormatChangedEvent;
|
|
}
|
|
|
|
void USequencerSettings::SetTimeDisplayFormat(EFrameNumberDisplayFormats InFormat)
|
|
{
|
|
if (InFormat != FrameNumberDisplayFormat)
|
|
{
|
|
FrameNumberDisplayFormat = InFormat;
|
|
SaveConfig();
|
|
OnTimeDisplayFormatChangedEvent.Broadcast();
|
|
}
|
|
}
|
|
|
|
void USequencerSettings::SetMovieRendererName(const FString& InMovieRendererName)
|
|
{
|
|
if (InMovieRendererName != MovieRendererName)
|
|
{
|
|
MovieRendererName = InMovieRendererName;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
void USequencerSettings::SetAutoExpandNodesOnSelection(bool bInAutoExpandNodesOnSelection)
|
|
{
|
|
if (bInAutoExpandNodesOnSelection != bAutoExpandNodesOnSelection)
|
|
{
|
|
bAutoExpandNodesOnSelection = bInAutoExpandNodesOnSelection;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
void USequencerSettings::SetRestoreOriginalViewportOnCameraCutUnlock(bool bInRestoreOriginalViewportOnCameraCutUnlock)
|
|
{
|
|
if (bInRestoreOriginalViewportOnCameraCutUnlock != bRestoreOriginalViewportOnCameraCutUnlock)
|
|
{
|
|
bRestoreOriginalViewportOnCameraCutUnlock = bInRestoreOriginalViewportOnCameraCutUnlock;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
void USequencerSettings::SetTreeViewWidth(float InTreeViewWidth)
|
|
{
|
|
if (InTreeViewWidth != TreeViewWidth)
|
|
{
|
|
TreeViewWidth = InTreeViewWidth;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
UE::Sequencer::EViewDensity USequencerSettings::GetViewDensity() const
|
|
{
|
|
static FName NAME_Compact("Compact");
|
|
static FName NAME_Relaxed("Relaxed");
|
|
if (ViewDensity == NAME_Compact)
|
|
{
|
|
return UE::Sequencer::EViewDensity::Compact;
|
|
}
|
|
if (ViewDensity == NAME_Relaxed)
|
|
{
|
|
return UE::Sequencer::EViewDensity::Relaxed;
|
|
}
|
|
return UE::Sequencer::EViewDensity::Variable;
|
|
}
|
|
|
|
void USequencerSettings::SetViewDensity(FName InViewDensity)
|
|
{
|
|
if (InViewDensity != ViewDensity)
|
|
{
|
|
ViewDensity = InViewDensity;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
void USequencerSettings::SetAssetBrowserWidth(float InAssetBrowserWidth)
|
|
{
|
|
if (InAssetBrowserWidth != AssetBrowserWidth)
|
|
{
|
|
AssetBrowserWidth = InAssetBrowserWidth;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
void USequencerSettings::SetAssetBrowserHeight(float InAssetBrowserHeight)
|
|
{
|
|
if (InAssetBrowserHeight != AssetBrowserHeight)
|
|
{
|
|
AssetBrowserHeight = InAssetBrowserHeight;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
FSidebarState& USequencerSettings::GetSidebarState()
|
|
{
|
|
return SidebarState.FindOrAdd(GetFName());
|
|
}
|
|
|
|
void USequencerSettings::SetSidebarState(const FSidebarState& InSidebarState)
|
|
{
|
|
FSidebarState& State = SidebarState.FindOrAdd(GetFName());
|
|
State = InSidebarState;
|
|
SaveConfig();
|
|
}
|
|
|
|
void USequencerSettings::SetOutlinerColumnVisibility(const TArray<FColumnVisibilitySetting>& InColumnVisibilitySettings)
|
|
{
|
|
if (InColumnVisibilitySettings != ColumnVisibilitySettings)
|
|
{
|
|
ColumnVisibilitySettings = InColumnVisibilitySettings;
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
FSequencerFilterBarConfig& USequencerSettings::FindOrAddTrackFilterBar(const FName InIdentifier, const bool bInSaveConfig)
|
|
{
|
|
FSequencerFilterBarConfig& FilterBarSettings = TrackFilterBars.FindOrAdd(InIdentifier);
|
|
|
|
if (bInSaveConfig)
|
|
{
|
|
SaveConfig();
|
|
}
|
|
|
|
return FilterBarSettings;
|
|
}
|
|
|
|
FSequencerFilterBarConfig* USequencerSettings::FindTrackFilterBar(const FName InIdentifier)
|
|
{
|
|
return TrackFilterBars.Find(InIdentifier);
|
|
}
|
|
|
|
bool USequencerSettings::RemoveTrackFilterBar(const FName InIdentifier)
|
|
{
|
|
const int32 RemovedCount = TrackFilterBars.Remove(InIdentifier) > 0;
|
|
SaveConfig();
|
|
return RemovedCount > 0;
|
|
}
|
|
|
|
bool USequencerSettings::GetIncludePinnedInFilter() const
|
|
{
|
|
return bIncludePinnedInFilter;
|
|
}
|
|
|
|
void USequencerSettings::SetIncludePinnedInFilter(const bool bInIncludePinned)
|
|
{
|
|
bIncludePinnedInFilter = bInIncludePinned;
|
|
SaveConfig();
|
|
}
|
|
|
|
bool USequencerSettings::GetAutoExpandNodesOnFilterPass() const
|
|
{
|
|
return bAutoExpandNodesOnFilterPass;
|
|
}
|
|
|
|
void USequencerSettings::SetAutoExpandNodesOnFilterPass(const bool bInIncludeParents)
|
|
{
|
|
bAutoExpandNodesOnFilterPass = bInIncludeParents;
|
|
SaveConfig();
|
|
}
|
|
|
|
bool USequencerSettings::GetUseFilterSubmenusForCategories() const
|
|
{
|
|
return bUseFilterSubmenusForCategories;
|
|
}
|
|
|
|
void USequencerSettings::SetUseFilterSubmenusForCategories(const bool bInUseFilterSubmenusForCategories)
|
|
{
|
|
bUseFilterSubmenusForCategories = bInUseFilterSubmenusForCategories;
|
|
SaveConfig();
|
|
}
|
|
|
|
bool USequencerSettings::IsFilterBarVisible() const
|
|
{
|
|
return bFilterBarVisible;
|
|
}
|
|
|
|
void USequencerSettings::SetFilterBarVisible(const bool bInVisible)
|
|
{
|
|
bFilterBarVisible = bInVisible;
|
|
SaveConfig();
|
|
}
|
|
|
|
EFilterBarLayout USequencerSettings::GetFilterBarLayout() const
|
|
{
|
|
return LastFilterBarLayout;
|
|
}
|
|
|
|
void USequencerSettings::SetFilterBarLayout(const EFilterBarLayout InLayout)
|
|
{
|
|
LastFilterBarLayout = InLayout;
|
|
SaveConfig();
|
|
}
|
|
|
|
float USequencerSettings::GetLastFilterBarSizeCoefficient() const
|
|
{
|
|
return LastFilterBarSizeCoefficient;
|
|
}
|
|
|
|
void USequencerSettings::SetLastFilterBarSizeCoefficient(const float bInSizeCoefficient)
|
|
{
|
|
LastFilterBarSizeCoefficient = bInSizeCoefficient;
|
|
SaveConfig();
|
|
}
|
|
|
|
void USequencerSettings::SetThumbnailCaptureSettings(const FSequencerThumbnailCaptureSettings& InNewValue)
|
|
{
|
|
ThumbnailCaptureSettings = InNewValue;
|
|
SaveConfig();
|
|
}
|
|
|
|
bool USequencerSettings::ShouldShowThumbnailCaptureSettings()
|
|
{
|
|
return UE::Sequencer::CVarEnableRelevantThumbnails.GetValueOnGameThread();
|
|
}
|
|
|
|
void USequencerSettings::SetNavigationToolVisible(const bool bInVisible)
|
|
{
|
|
if (bNavigationToolVisible != bInVisible)
|
|
{
|
|
bNavigationToolVisible = bInVisible;
|
|
SaveConfig();
|
|
}
|
|
}
|