// Copyright Epic Games, Inc. All Rights Reserved.


#include "SCurveEditor.h"
#include "Fonts/SlateFontInfo.h"
#include "Rendering/DrawElements.h"
#include "Widgets/SBoxPanel.h"
#include "Styling/SlateTypes.h"
#include "Styling/CoreStyle.h"
#include "Layout/WidgetPath.h"
#include "Framework/Application/MenuStack.h"
#include "Fonts/FontMeasure.h"
#include "Framework/Application/SlateApplication.h"
#include "Textures/SlateIcon.h"
#include "Framework/Commands/UIAction.h"
#include "Framework/Commands/UICommandList.h"
#include "Widgets/Layout/SBorder.h"
#include "Widgets/Images/SImage.h"
#include "Widgets/Text/STextBlock.h"
#include "Widgets/Layout/SBox.h"
#include "Framework/MultiBox/MultiBoxBuilder.h"
#include "Widgets/Input/SButton.h"
#include "Widgets/SToolTip.h"
#include "Widgets/Notifications/SErrorText.h"
#include "Widgets/Input/SCheckBox.h"
#include "Styling/AppStyle.h"
#include "Factories/Factory.h"
#include "Factories/CurveFactory.h"
#include "Editor.h"
#include "Curves/SimpleCurve.h"
#include "CurveEditorCommands.h"
#include "CurveEditorSettings.h"
#include "ScopedTransaction.h"
#include "Framework/Commands/GenericCommands.h"
#include "Widgets/Input/SNumericEntryBox.h"
#include "Widgets/Input/STextEntryPopup.h"
#include "Widgets/Notifications/SNotificationList.h"
#include "Framework/Notifications/NotificationManager.h"
#include "IPropertyUtilities.h"
#include "PropertyHandle.h"

#define LOCTEXT_NAMESPACE "SCurveEditor"
 
DEFINE_LOG_CATEGORY(LogCurveEditor);

const static FVector2D	CONST_KeySize		= FVector2D(11,11);
const static FVector2D	CONST_TangentSize	= FVector2D(7,7);
const static FVector2D	CONST_CurveSize		= FVector2D(12,12);

const static float		CONST_FitMargin		= 0.05f;
const static float		CONST_MinViewRange	= 0.01f;
const static float		CONST_DefaultZoomRange	= 1.0f;
const static float      CONST_KeyTangentOffset = 60.0f;


//////////////////////////////////////////////////////////////////////////
// SCurveEditor

void SCurveEditor::Construct(const FArguments& InArgs)
{
	CurveFactory = NULL;
	Commands = TSharedPtr< FUICommandList >(new FUICommandList);
	CurveOwner = NULL;
	
	// view input
	ViewMinInput = InArgs._ViewMinInput;
	ViewMaxInput = InArgs._ViewMaxInput;
	// data input - only used when it's set
	DataMinInput = InArgs._DataMinInput;
	DataMaxInput = InArgs._DataMaxInput;

	ViewMinOutput = InArgs._ViewMinOutput;
	ViewMaxOutput = InArgs._ViewMaxOutput;

	InputSnap = InArgs._InputSnap;
	OutputSnap = InArgs._OutputSnap;
	bInputSnappingEnabled = InArgs._InputSnappingEnabled;
	bOutputSnappingEnabled = InArgs._OutputSnappingEnabled;
	bShowTimeInFrames = InArgs._ShowTimeInFrames;

	bZoomToFitVertical = InArgs._ZoomToFitVertical;
	bZoomToFitHorizontal = InArgs._ZoomToFitHorizontal;
	DesiredSize = InArgs._DesiredSize;

	GridColor = InArgs._GridColor;

	bIsUsingSlider = false;
	bAllowAutoFrame = true;
	bRequireFocusToZoom = false;

	bIsPendingRebuilt = false;

	// if editor size is set, use it, otherwise, use default value
	if (DesiredSize.Get().IsZero())
	{
		DesiredSize.Set(FVector2D(128, 64));
	}

	TimelineLength = InArgs._TimelineLength;
	SetInputViewRangeHandler = InArgs._OnSetInputViewRange;
	SetOutputViewRangeHandler = InArgs._OnSetOutputViewRange;
	bDrawCurve = InArgs._DrawCurve;
	bHideUI = InArgs._HideUI;
	bAllowZoomOutput = InArgs._AllowZoomOutput;
	bAlwaysDisplayColorCurves = InArgs._AlwaysDisplayColorCurves;
	bAlwaysHideGradientEditor = InArgs._AlwaysHideGradientEditor;
	bShowZoomButtons = InArgs._ShowZoomButtons;
	bShowCurveSelector = InArgs._ShowCurveSelector;
	bDrawInputGridNumbers = InArgs._ShowInputGridNumbers;
	bDrawOutputGridNumbers = InArgs._ShowOutputGridNumbers;
	bAreCurvesVisible = InArgs._AreCurvesVisible;
	SetAreCurvesVisibleHandler = InArgs._OnSetAreCurvesVisible;

	OnCreateAsset = InArgs._OnCreateAsset;

	DragState = EDragState::None;
	DragThreshold = 4;

	MovementAxisLock = EMovementAxisLock::None;

	TransactionIndex = -1;

	ReduceTolerance = 0.001;

	Settings = GetMutableDefault<UCurveEditorSettings>();

	Commands->MapAction(FGenericCommands::Get().Undo,
		FExecuteAction::CreateSP(this, &SCurveEditor::UndoAction));

	Commands->MapAction(FGenericCommands::Get().Redo,
		FExecuteAction::CreateSP(this, &SCurveEditor::RedoAction));

	Commands->MapAction(FCurveEditorCommands::Get().ZoomToFitHorizontal,
		FExecuteAction::CreateSP(this, &SCurveEditor::ZoomToFitHorizontal, false));

	Commands->MapAction(FCurveEditorCommands::Get().ZoomToFitVertical,
		FExecuteAction::CreateSP(this, &SCurveEditor::ZoomToFitVertical, false));

	Commands->MapAction(FCurveEditorCommands::Get().ZoomToFit,
		FExecuteAction::CreateSP(this, &SCurveEditor::ZoomToFit, false));

	Commands->MapAction(FCurveEditorCommands::Get().ZoomToFitAll,
		FExecuteAction::CreateSP(this, &SCurveEditor::ZoomToFit, true));

	Commands->MapAction(FCurveEditorCommands::Get().ToggleInputSnapping,
		FExecuteAction::CreateSP(this, &SCurveEditor::ToggleInputSnapping),
		FCanExecuteAction(),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsInputSnappingEnabled));

	Commands->MapAction(FCurveEditorCommands::Get().ToggleOutputSnapping,
		FExecuteAction::CreateSP(this, &SCurveEditor::ToggleOutputSnapping),
		FCanExecuteAction(),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsOutputSnappingEnabled));

	// Interpolation
	Commands->MapAction(FCurveEditorCommands::Get().InterpolationConstant,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectInterpolationMode, RCIM_Constant, RCTM_Auto),
		FCanExecuteAction(),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsInterpolationModeSelected, RCIM_Constant, RCTM_Auto));

	Commands->MapAction(FCurveEditorCommands::Get().InterpolationLinear,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectInterpolationMode, RCIM_Linear, RCTM_Auto),
		FCanExecuteAction(),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsInterpolationModeSelected, RCIM_Linear, RCTM_Auto));

	Commands->MapAction(FCurveEditorCommands::Get().InterpolationCubicAuto,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectInterpolationMode, RCIM_Cubic, RCTM_Auto),
		FCanExecuteAction::CreateSP(this, &SCurveEditor::HasRichCurves),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsInterpolationModeSelected, RCIM_Cubic, RCTM_Auto));

	Commands->MapAction(FCurveEditorCommands::Get().InterpolationCubicSmartAuto,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectInterpolationMode, RCIM_Cubic, RCTM_SmartAuto),
		FCanExecuteAction::CreateSP(this, &SCurveEditor::HasRichCurves),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsInterpolationModeSelected, RCIM_Cubic, RCTM_SmartAuto));

	Commands->MapAction(FCurveEditorCommands::Get().InterpolationCubicUser,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectInterpolationMode, RCIM_Cubic, RCTM_User),
		FCanExecuteAction::CreateSP(this, &SCurveEditor::HasRichCurves),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsInterpolationModeSelected, RCIM_Cubic, RCTM_User));

	Commands->MapAction(FCurveEditorCommands::Get().InterpolationCubicBreak,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectInterpolationMode, RCIM_Cubic, RCTM_Break),
		FCanExecuteAction::CreateSP(this, &SCurveEditor::HasRichCurves),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsInterpolationModeSelected, RCIM_Cubic, RCTM_Break));

	// Tangents
	Commands->MapAction(FCurveEditorCommands::Get().FlattenTangents,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnFlattenOrStraightenTangents, true),
		FCanExecuteAction::CreateSP(this, &SCurveEditor::HasRichCurves));

	Commands->MapAction(FCurveEditorCommands::Get().StraightenTangents,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnFlattenOrStraightenTangents, false),
		FCanExecuteAction::CreateSP(this, &SCurveEditor::HasRichCurves));

	// Bake and reduce
	Commands->MapAction(FCurveEditorCommands::Get().BakeCurve,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnBakeCurve));

	Commands->MapAction(FCurveEditorCommands::Get().ReduceCurve,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnReduceCurve));

	// Pre infinity extrapolation
	Commands->MapAction(FCurveEditorCommands::Get().SetPreInfinityExtrapCycle,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectPreInfinityExtrap, RCCE_Cycle),
		FCanExecuteAction(),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsPreInfinityExtrapSelected, RCCE_Cycle));

	Commands->MapAction(FCurveEditorCommands::Get().SetPreInfinityExtrapCycleWithOffset,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectPreInfinityExtrap, RCCE_CycleWithOffset),
		FCanExecuteAction(),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsPreInfinityExtrapSelected, RCCE_CycleWithOffset));

	Commands->MapAction(FCurveEditorCommands::Get().SetPreInfinityExtrapOscillate,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectPreInfinityExtrap, RCCE_Oscillate),
		FCanExecuteAction(),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsPreInfinityExtrapSelected, RCCE_Oscillate));

	Commands->MapAction(FCurveEditorCommands::Get().SetPreInfinityExtrapLinear,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectPreInfinityExtrap, RCCE_Linear),
		FCanExecuteAction(),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsPreInfinityExtrapSelected, RCCE_Linear));

	Commands->MapAction(FCurveEditorCommands::Get().SetPreInfinityExtrapConstant,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectPreInfinityExtrap, RCCE_Constant),
		FCanExecuteAction(),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsPreInfinityExtrapSelected, RCCE_Constant));

	// Post infinity extrapolation
	Commands->MapAction(FCurveEditorCommands::Get().SetPostInfinityExtrapCycle,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectPostInfinityExtrap, RCCE_Cycle),
		FCanExecuteAction(),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsPostInfinityExtrapSelected, RCCE_Cycle));

	Commands->MapAction(FCurveEditorCommands::Get().SetPostInfinityExtrapCycleWithOffset,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectPostInfinityExtrap, RCCE_CycleWithOffset),
		FCanExecuteAction(),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsPostInfinityExtrapSelected, RCCE_CycleWithOffset));

	Commands->MapAction(FCurveEditorCommands::Get().SetPostInfinityExtrapOscillate,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectPostInfinityExtrap, RCCE_Oscillate),
		FCanExecuteAction(),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsPostInfinityExtrapSelected, RCCE_Oscillate));

	Commands->MapAction(FCurveEditorCommands::Get().SetPostInfinityExtrapLinear,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectPostInfinityExtrap, RCCE_Linear),
		FCanExecuteAction(),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsPostInfinityExtrapSelected, RCCE_Linear));

	Commands->MapAction(FCurveEditorCommands::Get().SetPostInfinityExtrapConstant,
		FExecuteAction::CreateSP(this, &SCurveEditor::OnSelectPostInfinityExtrap, RCCE_Constant),
		FCanExecuteAction(),
		FIsActionChecked::CreateSP(this, &SCurveEditor::IsPostInfinityExtrapSelected, RCCE_Constant));

	// Tangent Visibility
	Commands->MapAction(FCurveEditorCommands::Get().SetAllTangentsVisibility,
		FExecuteAction::CreateLambda( [this]{ Settings->SetTangentVisibility( ECurveEditorTangentVisibility::AllTangents ); } ),
		FCanExecuteAction::CreateLambda( []{ return true; } ),
		FIsActionChecked::CreateLambda( [this]{ return Settings->GetTangentVisibility() == ECurveEditorTangentVisibility::AllTangents; } ) );

	Commands->MapAction(FCurveEditorCommands::Get().SetUserTangentsVisibility,
		FExecuteAction::CreateLambda( [this]{ Settings->SetTangentVisibility( ECurveEditorTangentVisibility::UserTangents ); } ),
		FCanExecuteAction::CreateLambda( []{ return true; } ),
		FIsActionChecked::CreateLambda( [this]{ return Settings->GetTangentVisibility() == ECurveEditorTangentVisibility::UserTangents; } ) );
	
	Commands->MapAction(FCurveEditorCommands::Get().SetSelectedKeysTangentVisibility,
		FExecuteAction::CreateLambda( [this]{ Settings->SetTangentVisibility( ECurveEditorTangentVisibility::SelectedKeys ); } ),
		FCanExecuteAction::CreateLambda( []{ return true; } ),
		FIsActionChecked::CreateLambda( [this]{ return Settings->GetTangentVisibility() == ECurveEditorTangentVisibility::SelectedKeys; } ) );

	Commands->MapAction(FCurveEditorCommands::Get().SetNoTangentsVisibility,
		FExecuteAction::CreateLambda( [this]{ Settings->SetTangentVisibility( ECurveEditorTangentVisibility::NoTangents ); } ),
		FCanExecuteAction::CreateLambda( []{ return true; } ),
		FIsActionChecked::CreateLambda( [this]{ return Settings->GetTangentVisibility() == ECurveEditorTangentVisibility::NoTangents; } ) );

	Commands->MapAction(FCurveEditorCommands::Get().ToggleAutoFrameCurveEditor,
		FExecuteAction::CreateLambda( [this]{ Settings->SetAutoFrameCurveEditor( !Settings->GetAutoFrameCurveEditor() ); } ),
		FCanExecuteAction::CreateLambda( []{ return true; } ),
		FIsActionChecked::CreateLambda( [this]{ return Settings->GetAutoFrameCurveEditor(); } ) );

	Commands->MapAction(FCurveEditorCommands::Get().ToggleShowCurveEditorCurveToolTips,
		FExecuteAction::CreateLambda( [this]{ 
		Settings->SetShowCurveEditorCurveToolTips( !Settings->GetShowCurveEditorCurveToolTips() ); 
		if (!Settings->GetShowCurveEditorCurveToolTips())
		{
			CurveToolTip.Reset();
			SetToolTip(CurveToolTip);
		} } ),
		FCanExecuteAction::CreateLambda( []{ return true; } ),
		FIsActionChecked::CreateLambda( [this]{ return Settings->GetShowCurveEditorCurveToolTips(); } ) );

	FCoreUObjectDelegates::OnPackageReloaded.AddSP(this, &SCurveEditor::HandlePackageReloaded);

	SAssignNew(WarningMessageText, SErrorText);

	TSharedRef<SBox> CurveSelector = SNew(SBox)
		.VAlign(VAlign_Top)
		.Visibility(this, &SCurveEditor::GetCurveSelectorVisibility)
		[
			CreateCurveSelectionWidget()
		];

	CurveSelectionWidget = CurveSelector;

	InputAxisName = InArgs._XAxisName.IsSet() ? FText::FromString(InArgs._XAxisName.GetValue()) : LOCTEXT("Time", "Time");
	InputFrameAxisName = InArgs._XAxisName.IsSet() ? FText::FromString(InArgs._XAxisName.GetValue()) : LOCTEXT("Frame", "Frame");
	OutputAxisName = InArgs._YAxisName.IsSet() ? FText::FromString(InArgs._YAxisName.GetValue()) : LOCTEXT("Value", "Value");

	ChildSlot
	[
		SNew( SVerticalBox )
		+ SVerticalBox::Slot()
		.FillHeight(1.0f)
		[
			SNew(SHorizontalBox)
			.Visibility( this, &SCurveEditor::GetCurveAreaVisibility )
			+ SHorizontalBox::Slot()
			.AutoWidth()
			.Padding(FMargin(30, 12, 0, 0))
			[
				CurveSelector
			]

			+ SHorizontalBox::Slot()
			.AutoWidth()
			[
				SNew(SBorder)
				.VAlign(VAlign_Top)
				.HAlign(HAlign_Left)
				.BorderImage( FAppStyle::GetBrush("NoBorder") )
				.DesiredSizeScale(FVector2D(256.0f,32.0f))
				.Padding(FMargin(2, 12, 0, 0))
				[
					SNew(SHorizontalBox)

					+ SHorizontalBox::Slot()
					.AutoWidth()
					[
						SNew(SButton)
						.ToolTipText(LOCTEXT("ZoomToFitHorizontal", "Zoom To Fit Horizontal"))
						.Visibility(this, &SCurveEditor::GetZoomButtonVisibility)
						.OnClicked(this, &SCurveEditor::ZoomToFitHorizontalClicked)
						.ContentPadding(1)
						[
							SNew(SImage) 
							.Image( FAppStyle::GetBrush("CurveEd.FitHorizontal") ) 
							.ColorAndOpacity( FSlateColor::UseForeground() ) 
						]
					]
						
					+ SHorizontalBox::Slot()
					.AutoWidth()
					[
						SNew(SButton)
						.ToolTipText(LOCTEXT("ZoomToFitVertical", "Zoom To Fit Vertical"))
						.Visibility(this, &SCurveEditor::GetZoomButtonVisibility)
						.OnClicked(this, &SCurveEditor::ZoomToFitVerticalClicked)
						.ContentPadding(1)
						[
							SNew(SImage) 
							.Image( FAppStyle::GetBrush("CurveEd.FitVertical") ) 
							.ColorAndOpacity( FSlateColor::UseForeground() ) 
						]
					]

					+ SHorizontalBox::Slot()
					.AutoWidth()
					[
						SNew(SHorizontalBox)
						+ SHorizontalBox::Slot()
						.Padding(6.0f, 0.0, 3.0f, 0.0f)
						.VAlign(VAlign_Center)
						[
							SNew(STextBlock)
							.Visibility(this, &SCurveEditor::GetEditVisibility)
							.Text(this, &SCurveEditor::GetInputAxisName)
							.ShadowOffset(FVector2D(1,1))
						]
						+ SHorizontalBox::Slot()
						.VAlign(VAlign_Center)
						.AutoWidth()
						[
							SNew(SNumericEntryBox<float>)
							.IsEnabled(this, &SCurveEditor::GetInputEditEnabled)
							.Value(this, &SCurveEditor::OnGetTime)
							.UndeterminedString(LOCTEXT("MultipleValues", "Multiple Values"))
							.OnValueCommitted(this, &SCurveEditor::OnTimeComitted)
							.OnValueChanged(this, &SCurveEditor::OnTimeChanged)
							.OnBeginSliderMovement(this, &SCurveEditor::OnBeginSliderMovement, LOCTEXT("SetTime", "Set New Time"))
							.OnEndSliderMovement(this, &SCurveEditor::OnEndSliderMovement)
							.AllowSpin(true)
							.MinValue(TOptional<float>())
							.MaxValue(TOptional<float>())
							.MaxSliderValue(TOptional<float>())
							.MinSliderValue(TOptional<float>())
							.Delta(this, &SCurveEditor::GetInputNumericEntryBoxDelta)
							.MinDesiredValueWidth(60.0f)
							.Visibility(this, &SCurveEditor::GetTimeEditVisibility)
								
						]
						+ SHorizontalBox::Slot()
						.Padding(3.0f, 0.0f)
						.VAlign(VAlign_Center)
						.AutoWidth()
						[
							SNew(SNumericEntryBox<int32>)
							.IsEnabled(this, &SCurveEditor::GetInputEditEnabled)
							.Value(this, &SCurveEditor::OnGetTimeInFrames)
							.UndeterminedString(LOCTEXT("MultipleValues", "Multiple Values"))
							.OnValueCommitted(this, &SCurveEditor::OnTimeInFramesComitted)
							.OnValueChanged(this, &SCurveEditor::OnTimeInFramesChanged)
							.OnBeginSliderMovement(this, &SCurveEditor::OnBeginSliderMovement, LOCTEXT("SetFrame", "Set New Frame"))
							.OnEndSliderMovement(this, &SCurveEditor::OnEndSliderMovement)
							.LabelVAlign(VAlign_Center)
							.AllowSpin(true)
							.MinValue(TOptional<int32>())
							.MaxValue(TOptional<int32>())
							.MaxSliderValue(TOptional<int32>())
							.MinSliderValue(TOptional<int32>())
							.Delta(1)
							.MinDesiredValueWidth(60.0f)
							.Visibility(this, &SCurveEditor::GetFrameEditVisibility)
						]
					]
					+ SHorizontalBox::Slot()
					.Padding(3.0f, 0.0f)
					.VAlign(VAlign_Center)
					[
						SNew(STextBlock)
						.Visibility(this, &SCurveEditor::GetEditVisibility)
						.Text(OutputAxisName)
						.ShadowOffset(FVector2D(1, 1))
					]
					+ SHorizontalBox::Slot()
					.VAlign(VAlign_Center)
					.AutoWidth()
					[
						SNew(SNumericEntryBox<float>)
						.Visibility(this, &SCurveEditor::GetEditVisibility)
						.Value(this, &SCurveEditor::OnGetValue)
						.UndeterminedString(LOCTEXT("MultipleValues", "Multiple Values"))
						.OnValueCommitted(this, &SCurveEditor::OnValueComitted)
						.OnValueChanged(this, &SCurveEditor::OnValueChanged)
						.OnBeginSliderMovement(this, &SCurveEditor::OnBeginSliderMovement, LOCTEXT("SetValue", "Set New Value"))
						.OnEndSliderMovement(this, &SCurveEditor::OnEndSliderMovement)
						.AllowSpin(true)
						.MinValue(TOptional<float>())
						.MaxValue(TOptional<float>())
						.MaxSliderValue(TOptional<float>())
						.MinSliderValue(TOptional<float>())
						.Delta(this, &SCurveEditor::GetOutputNumericEntryBoxDelta)
						.MinDesiredValueWidth(60.0f)
					]
				]
			]
		]
		+ SVerticalBox::Slot()
		.VAlign(VAlign_Bottom)
		.FillHeight(.75f)
		[
			SNew( SBorder )
			.Visibility( this, &SCurveEditor::GetColorGradientVisibility )
			.BorderImage( FAppStyle::GetBrush("ToolPanel.GroupBorder") )
			.BorderBackgroundColor( FLinearColor( .8f, .8f, .8f, .60f ) )
			.Padding(1.0f)
			[
				SAssignNew( GradientViewer, SColorGradientEditor )
				.ViewMinInput( ViewMinInput )
				.ViewMaxInput( ViewMaxInput )
				.IsEditingEnabled( this, &SCurveEditor::IsEditingEnabled )
			]
		]
	];

	if (GEditor != NULL)
	{
		GEditor->RegisterForUndo(this);
	}

	FCoreUObjectDelegates::OnObjectPropertyChanged.AddSP(this, &SCurveEditor::OnObjectPropertyChanged);
}

FText SCurveEditor::GetIsCurveVisibleToolTip(TSharedPtr<FCurveViewModel> CurveViewModel) const
{
	return CurveViewModel->bIsVisible ?
		FText::Format(LOCTEXT("HideFormat", "Hide {0} curve"), FText::FromName(CurveViewModel->CurveInfo.CurveName)) :
		FText::Format(LOCTEXT("ShowFormat", "Show {0} curve"), FText::FromName(CurveViewModel->CurveInfo.CurveName));
}

ECheckBoxState SCurveEditor::IsCurveVisible(TSharedPtr<FCurveViewModel> CurveViewModel) const
{
	return CurveViewModel->bIsVisible ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
}

void SCurveEditor::OnCurveIsVisibleChanged(ECheckBoxState NewCheckboxState, TSharedPtr<FCurveViewModel> CurveViewModel)
{
	if (NewCheckboxState == ECheckBoxState::Checked)
	{
		CurveViewModel->bIsVisible = true;
	}
	else
	{
		CurveViewModel->bIsVisible = false;
		RemoveCurveKeysFromSelection(CurveViewModel);
	}
}

FText SCurveEditor::GetIsCurveLockedToolTip(TSharedPtr<FCurveViewModel> CurveViewModel) const
{
	return CurveViewModel->bIsLocked ?
		FText::Format(LOCTEXT("UnlockFormat", "Unlock {0} curve for editing"), FText::FromName(CurveViewModel->CurveInfo.CurveName)) :
		FText::Format(LOCTEXT("LockFormat", "Lock {0} curve for editing"), FText::FromName(CurveViewModel->CurveInfo.CurveName));
}

ECheckBoxState SCurveEditor::IsCurveLocked(TSharedPtr<FCurveViewModel> CurveViewModel) const
{
	return CurveViewModel->bIsLocked ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
}

void SCurveEditor::OnCurveIsLockedChanged(ECheckBoxState NewCheckboxState, TSharedPtr<FCurveViewModel> CurveViewModel)
{
	if (NewCheckboxState == ECheckBoxState::Checked)
	{
		CurveViewModel->bIsLocked = true;
		RemoveCurveKeysFromSelection(CurveViewModel);
	}
	else
	{
		CurveViewModel->bIsLocked = false;
	}
}

void SCurveEditor::RemoveCurveKeysFromSelection(TSharedPtr<FCurveViewModel> CurveViewModel)
{
	TArray<FSelectedCurveKey> SelectedKeysForLockedCurve;
	for (auto SelectedKey : SelectedKeys)
	{
		if (SelectedKey.Curve == CurveViewModel->CurveInfo.CurveToEdit)
		{
			SelectedKeysForLockedCurve.Add(SelectedKey);
		}
	}
	for (auto KeyToDeselect : SelectedKeysForLockedCurve)
	{
		RemoveFromKeySelection(KeyToDeselect);
	}
}

FText SCurveEditor::GetCurveToolTipNameText() const
{
	return CurveToolTipNameText;
}

FText SCurveEditor::GetCurveToolTipInputText() const
{
	return CurveToolTipInputText;
}

FText SCurveEditor::GetCurveToolTipOutputText() const
{
	return CurveToolTipOutputText;
}

FText SCurveEditor::GetInputAxisName() const
{
	return ShowTimeInFrames() ? InputFrameAxisName : InputAxisName;
}

SCurveEditor::~SCurveEditor()
{
	if (GEditor != NULL)
	{
		GEditor->UnregisterForUndo(this);
	}

	FCoreUObjectDelegates::OnObjectPropertyChanged.RemoveAll(this);
}

TSharedRef<SWidget> SCurveEditor::CreateCurveSelectionWidget() const
{
	TSharedRef<SVerticalBox> CurveBox = SNew(SVerticalBox);
	if (CurveViewModels.Num() > 1)
	{
		// Only create curve controls if there are more than one.
		for (auto CurveViewModel : CurveViewModels)
		{
			CurveBox->AddSlot()
			.AutoHeight()
			[
				SNew(SHorizontalBox)

				+ SHorizontalBox::Slot()
				.Padding(0, 0, 5, 0)
				.FillWidth(1.0f)
				[
					SNew(STextBlock)
					.Font(FAppStyle::GetFontStyle("CurveEd.LabelFont"))
					.ColorAndOpacity(CurveViewModel->Color)
					.Text(FText::FromName(CurveViewModel->CurveInfo.CurveName))
				]

				+ SHorizontalBox::Slot()
				.AutoWidth()
				.VAlign(VAlign_Fill)
				[
					SNew(SCheckBox)
					.Style(&FAppStyle::Get().GetWidgetStyle<FCheckBoxStyle>("ToggleButtonCheckbox"))
					.IsChecked(this, &SCurveEditor::IsCurveVisible, CurveViewModel)
					.OnCheckStateChanged(const_cast<SCurveEditor*>(this), &SCurveEditor::OnCurveIsVisibleChanged, CurveViewModel)
					.ToolTipText(this, &SCurveEditor::GetIsCurveVisibleToolTip, CurveViewModel)
					.CheckedImage(FAppStyle::Get().GetBrush("Icons.Visible"))
					.CheckedHoveredImage(FAppStyle::Get().GetBrush("Icons.Visible"))
					.CheckedPressedImage(FAppStyle::Get().GetBrush("Icons.Visible"))
					.UncheckedImage(FAppStyle::Get().GetBrush("Icons.Hidden"))
					.UncheckedHoveredImage(FAppStyle::Get().GetBrush("Icons.Hidden"))
					.UncheckedPressedImage(FAppStyle::Get().GetBrush("Icons.Hidden"))
					.Padding(8.0f)
				]

				+ SHorizontalBox::Slot()
				.AutoWidth()
				.VAlign(VAlign_Fill)
				.Padding(2, 0, 0, 0)
				[
					SNew(SCheckBox)
					.Style(&FAppStyle::Get().GetWidgetStyle<FCheckBoxStyle>("ToggleButtonCheckbox"))
					.IsChecked(this, &SCurveEditor::IsCurveLocked, CurveViewModel)
					.OnCheckStateChanged(const_cast<SCurveEditor*>(this), &SCurveEditor::OnCurveIsLockedChanged, CurveViewModel)
					.ToolTipText(this, &SCurveEditor::GetIsCurveLockedToolTip, CurveViewModel)
					.CheckedImage(FAppStyle::Get().GetBrush("Icons.Lock"))
					.CheckedHoveredImage(FAppStyle::Get().GetBrush("Icons.Lock"))
					.CheckedPressedImage(FAppStyle::Get().GetBrush("Icons.Lock"))
					.UncheckedImage(FAppStyle::Get().GetBrush("Icons.Unlock"))
					.UncheckedHoveredImage(FAppStyle::Get().GetBrush("Icons.Unlock"))
					.UncheckedPressedImage(FAppStyle::Get().GetBrush("Icons.Unlock"))
					.Padding(8.0f)
					.Visibility(bCanEditTrack ? EVisibility::Visible : EVisibility::Collapsed)
				]
			];
		}
	}

	TSharedRef<SBorder> Border = SNew(SBorder)
		.Padding(FMargin(3, 2, 2, 2))
		.BorderImage(FAppStyle::GetBrush("ToolPanel.GroupBorder"))
		.BorderBackgroundColor(FLinearColor(0.0f, 0.0f, 0.0f, 0.3f))
		[
			CurveBox
		];

	return Border;
}

void SCurveEditor::PushWarningMenu( FVector2D Position, const FText& Message )
{
	WarningMessageText->SetError(Message);

	FSlateApplication::Get().PushMenu(
		SharedThis( this ),
		FWidgetPath(),
		WarningMessageText->AsWidget(),
		Position,
		FPopupTransitionEffect( FPopupTransitionEffect::ContextMenu));
}

void SCurveEditor::PushKeyMenu(const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent)
{
	FMenuBuilder MenuBuilder(true, Commands.ToSharedRef());
	MenuBuilder.BeginSection("CurveEditorInterpolation", LOCTEXT("KeyInterpolationMode", "Key Interpolation"));
	{
		MenuBuilder.AddMenuEntry(FCurveEditorCommands::Get().InterpolationCubicAuto);
		MenuBuilder.AddMenuEntry(FCurveEditorCommands::Get().InterpolationCubicUser);
		MenuBuilder.AddMenuEntry(FCurveEditorCommands::Get().InterpolationCubicBreak);
		MenuBuilder.AddMenuEntry(FCurveEditorCommands::Get().InterpolationLinear);
		MenuBuilder.AddMenuEntry(FCurveEditorCommands::Get().InterpolationConstant);
	}
	MenuBuilder.EndSection(); //CurveEditorInterpolation

	MenuBuilder.BeginSection("CurveEditorTangents", LOCTEXT("Tangents", "Tangents"));
	{
		MenuBuilder.AddMenuEntry(FCurveEditorCommands::Get().FlattenTangents);
		MenuBuilder.AddMenuEntry(FCurveEditorCommands::Get().StraightenTangents);
	}
	MenuBuilder.EndSection(); //CurveEditorTangents

	FWidgetPath WidgetPath = InMouseEvent.GetEventPath() != nullptr ? *InMouseEvent.GetEventPath() : FWidgetPath();
	FVector2D Position = InMouseEvent.GetScreenSpacePosition();
	FSlateApplication::Get().PushMenu(
		SharedThis( this ),
		WidgetPath,
		MenuBuilder.MakeWidget(),
		Position,
		FPopupTransitionEffect( FPopupTransitionEffect::ContextMenu));
}


FVector2D SCurveEditor::ComputeDesiredSize( float ) const
{
	return DesiredSize.Get();
}

EVisibility SCurveEditor::GetCurveAreaVisibility() const
{
	return AreCurvesVisible() ? EVisibility::Visible : EVisibility::Collapsed;
}

EVisibility SCurveEditor::GetCurveSelectorVisibility() const
{
	return  (IsHovered() || (false == bHideUI)) && bShowCurveSelector ? EVisibility::Visible : EVisibility::Collapsed;
}

EVisibility SCurveEditor::GetEditVisibility() const
{
	return (SelectedKeys.Num() > 0) && (IsHovered() || (false == bHideUI)) ? EVisibility::Visible : EVisibility::Collapsed;
}

EVisibility SCurveEditor::GetColorGradientVisibility() const
{
	return IsGradientEditorVisible() && IsLinearColorCurve() ? EVisibility::Visible : EVisibility::Collapsed;
}

EVisibility SCurveEditor::GetZoomButtonVisibility() const
{
	return (IsHovered() || (false == bHideUI)) && bShowZoomButtons ? EVisibility::Visible : EVisibility::Collapsed;
}

EVisibility SCurveEditor::GetTimeEditVisibility() const
{
	if (GetEditVisibility().IsVisible())
	{
		return ShowTimeInFrames() ? EVisibility::Collapsed : EVisibility::Visible;
	}
	return EVisibility::Collapsed;
}

EVisibility SCurveEditor::GetFrameEditVisibility() const
{
	if (GetEditVisibility().IsVisible())
	{
		return ShowTimeInFrames() ? EVisibility::Visible : EVisibility::Collapsed;
	}
	return EVisibility::Collapsed;
}

bool SCurveEditor::GetInputEditEnabled() const
{
	bool bKeysOnSameCurves = false;
	for (int32 SelectedIndex = 0; SelectedIndex < SelectedKeys.Num() - 1; SelectedIndex++)
	{
		for (int32 CompareIndex = SelectedIndex + 1; CompareIndex < SelectedKeys.Num(); CompareIndex++)
		{
			if (SelectedKeys[SelectedIndex].Curve == SelectedKeys[CompareIndex].Curve)
			{
				bKeysOnSameCurves = true;
				break;
			}
		}
	}
	return (SelectedKeys.Num() == 1) || !bKeysOnSameCurves;
}

int32 SCurveEditor::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
	// Rendering info
	bool bEnabled = ShouldBeEnabled( bParentEnabled );
	ESlateDrawEffect DrawEffects = bEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
	const FSlateBrush* TimelineAreaBrush = FAppStyle::GetBrush("CurveEd.TimelineArea");
	const FSlateBrush* WhiteBrush = FAppStyle::GetBrush("WhiteTexture");

	FGeometry CurveAreaGeometry = AllottedGeometry;

	// Positioning info
	FTrackScaleInfo ScaleInfo(ViewMinInput.Get(),  ViewMaxInput.Get(), ViewMinOutput.Get(), ViewMaxOutput.Get(), CurveAreaGeometry.GetLocalSize());

	if (FMath::IsNearlyEqual(ViewMinInput.Get(), ViewMaxInput.Get()) || FMath::IsNearlyEqual(ViewMinOutput.Get(), ViewMaxOutput.Get()))
	{
		return 0;
	}

	// Draw background to indicate valid timeline area
	float ZeroInputX = ScaleInfo.InputToLocalX(0.f);
	float ZeroOutputY = ScaleInfo.OutputToLocalY(0.f);

	// timeline background
	int32 BackgroundLayerId = LayerId;
	float TimelineMaxX = ScaleInfo.InputToLocalX(TimelineLength.Get());
	FSlateDrawElement::MakeBox
		(
		OutDrawElements,
		BackgroundLayerId,
		CurveAreaGeometry.ToPaintGeometry(FVector2D(TimelineMaxX - ZeroInputX, CurveAreaGeometry.GetLocalSize().Y), FSlateLayoutTransform(FVector2D(ZeroInputX, 0.f))),
		TimelineAreaBrush,
		DrawEffects,
		TimelineAreaBrush->GetTint(InWidgetStyle) * InWidgetStyle.GetColorAndOpacityTint()
		);

	// grid lines.
	int32 GridLineLayerId = BackgroundLayerId + 1;
	PaintGridLines(CurveAreaGeometry, ScaleInfo, OutDrawElements, GridLineLayerId, MyCullingRect, DrawEffects);

	// time=0 line
	int32 ZeroLineLayerId = GridLineLayerId + 1;
	TArray<FVector2D> ZeroLinePoints;
	ZeroLinePoints.Add( FVector2D( ZeroInputX, 0 ) );
	ZeroLinePoints.Add( FVector2D( ZeroInputX, CurveAreaGeometry.GetLocalSize().Y ) );
	FSlateDrawElement::MakeLines(
		OutDrawElements,
		ZeroLineLayerId,
		AllottedGeometry.ToPaintGeometry(),
		ZeroLinePoints,
		DrawEffects,
		FLinearColor::White,
		false );

	// value=0 line
	if( AreCurvesVisible() )
	{
		FSlateDrawElement::MakeBox
		(
			OutDrawElements,
			ZeroLineLayerId,
			CurveAreaGeometry.ToPaintGeometry( FVector2D(CurveAreaGeometry.Size.X, 1), FSlateLayoutTransform(FVector2D(0.f, ZeroOutputY)) ),
			WhiteBrush,
			DrawEffects,
			WhiteBrush->GetTint( InWidgetStyle ) * InWidgetStyle.GetColorAndOpacityTint()
		);
	}

	int32 LockedCurveLayerID = ZeroLineLayerId + 1;
	int32 CurveLayerId = LockedCurveLayerID + 1;

	int32 KeyLayerId = CurveLayerId + 1;
	int32 SelectedKeyLayerId = KeyLayerId + 1;

	bool bAnyCurveViewModelsSelected = AnyCurveViewModelsSelected();

	if( AreCurvesVisible() )
	{
		//Paint the curves, unlocked curves will be on top
		for ( auto CurveViewModel : CurveViewModels )
		{
			if (CurveViewModel->bIsVisible)
			{
				PaintCurve(CurveViewModel, CurveAreaGeometry, ScaleInfo, OutDrawElements, CurveViewModel->bIsLocked ? LockedCurveLayerID : CurveLayerId, MyCullingRect, DrawEffects, InWidgetStyle, bAnyCurveViewModelsSelected);
			}
		}

		//Paint the keys on top of the curve
		for (auto CurveViewModel : CurveViewModels)
		{
			if (CurveViewModel->bIsVisible)
			{
				PaintKeys(CurveViewModel, ScaleInfo, OutDrawElements, KeyLayerId, SelectedKeyLayerId, CurveAreaGeometry, MyCullingRect, DrawEffects, InWidgetStyle, bAnyCurveViewModelsSelected);
			}
		}
	}

	// Paint children
	int32 ChildrenLayerId = SelectedKeyLayerId + 1;
	int32 MarqueeLayerId = SCompoundWidget::OnPaint(Args, CurveAreaGeometry, MyCullingRect, OutDrawElements, ChildrenLayerId, InWidgetStyle, bParentEnabled);

	// Paint marquee
	if (DragState == EDragState::MarqueeSelect)
	{
		PaintMarquee(AllottedGeometry, MyCullingRect, OutDrawElements, MarqueeLayerId);
	}

	return MarqueeLayerId + 1;
}

void SCurveEditor::PaintCurve(TSharedPtr<FCurveViewModel> CurveViewModel, const FGeometry &AllottedGeometry, FTrackScaleInfo &ScaleInfo, FSlateWindowElementList &OutDrawElements,
	int32 LayerId, const FSlateRect& MyCullingRect, ESlateDrawEffect DrawEffects, const FWidgetStyle &InWidgetStyle, bool bAnyCurveViewModelsSelected )const
{
	if (CurveViewModel.IsValid())
	{
		if (bDrawCurve)
		{
			FLinearColor Color = InWidgetStyle.GetColorAndOpacityTint() * CurveViewModel->Color;

			// Fade out curves that are not selected.
			if (!CurveViewModel->bIsSelected && bAnyCurveViewModelsSelected)
			{
				Color *= FLinearColor(1.0f,1.0f,1.0f,0.2f); 
			}

			// Fade out curves which are locked.
			if(CurveViewModel->bIsLocked)
			{
				Color *= FLinearColor(1.0f,1.0f,1.0f,0.35f); 
			}

			TArray<FVector2D> LinePoints;
			int32 CurveDrawInterval = 1;

			FRealCurve* Curve = CurveViewModel->CurveInfo.CurveToEdit;
			const float NumKeys = Curve->GetNumKeys();

			if (NumKeys < 2) 
			{
				//Not enough point, just draw flat line
				float Value = Curve->Eval(0.0f);
				float Y = ScaleInfo.OutputToLocalY(Value);
				LinePoints.Add(FVector2D(0.0f, Y));
				LinePoints.Add(FVector2D(AllottedGeometry.GetLocalSize().X, Y));

				FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), LinePoints, DrawEffects, Color);
				LinePoints.Empty();
			}
			else
			{
				TArray<FKeyHandle> KeyHandles;
				TArray<TPair<float,float>> Key_TimeValuePairs;
				KeyHandles.Reserve(NumKeys);
				Key_TimeValuePairs.Reserve(NumKeys);
				for (auto It = Curve->GetKeyHandleIterator(); It; ++It)
				{
					const FKeyHandle& KeyHandle = *It;

					KeyHandles.Add(KeyHandle);
					Key_TimeValuePairs.Emplace(Curve->GetKeyTimeValuePair(KeyHandle));
				}

				//Add arrive and exit lines
				{
					float ArriveX = ScaleInfo.InputToLocalX(Key_TimeValuePairs[0].Key);
					float ArriveY = ScaleInfo.OutputToLocalY(Key_TimeValuePairs[0].Value);
					float LeaveY  = ScaleInfo.OutputToLocalY(Key_TimeValuePairs.Last().Value);
					float LeaveX  = ScaleInfo.InputToLocalX(Key_TimeValuePairs.Last().Key);

					//Arrival line
					LinePoints.Add(FVector2D(0.0f, ArriveY));
					LinePoints.Add(FVector2D(ArriveX, ArriveY));
					FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), LinePoints, DrawEffects, Color);
					LinePoints.Empty();

					//Leave line
					LinePoints.Add(FVector2D(AllottedGeometry.GetLocalSize().X, LeaveY));
					LinePoints.Add(FVector2D(LeaveX, LeaveY));
					FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), LinePoints, DrawEffects, Color);
					LinePoints.Empty();
				}


				//Add enclosed segments
				for (int32 i = 0;i<NumKeys-1;++i)
				{
					CreateLinesForSegment(Curve, Curve->GetKeyInterpMode(KeyHandles[i]), Key_TimeValuePairs[i], Key_TimeValuePairs[i+1], LinePoints, ScaleInfo);
					FSlateDrawElement::MakeLines(OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), LinePoints, DrawEffects, Color);
					LinePoints.Empty();
				}
			}
		}
	}
}


void SCurveEditor::CreateLinesForSegment( FRealCurve* Curve, ERichCurveInterpMode InterpMode, const TPair<float,float>& Key1_TimeValue, const TPair<float,float>& Key2_TimeValue, TArray<FVector2D>& Points, FTrackScaleInfo &ScaleInfo ) const
{
	switch(InterpMode)
	{
	case RCIM_Constant:
		{
			//@todo: should really only need 3 points here but something about the line rendering isn't quite behaving as I'd expect, so need extras
			Points.Add(FVector2D(Key1_TimeValue.Key, Key1_TimeValue.Value));
			Points.Add(FVector2D(Key2_TimeValue.Key, Key1_TimeValue.Value));
			Points.Add(FVector2D(Key2_TimeValue.Key, Key1_TimeValue.Value));
			Points.Add(FVector2D(Key2_TimeValue.Key, Key2_TimeValue.Value));
			Points.Add(FVector2D(Key2_TimeValue.Key, Key1_TimeValue.Value));
		}break;
	case RCIM_Linear:
		{
			Points.Add(FVector2D(Key1_TimeValue.Key, Key1_TimeValue.Value));
			Points.Add(FVector2D(Key2_TimeValue.Key, Key2_TimeValue.Value));
		}break;
	case RCIM_Cubic:
		{
			const float StepSize = 1.0f;
			//clamp to screen to avoid massive slowdown when zoomed in
			float StartX	= FMath::Max(ScaleInfo.InputToLocalX(Key1_TimeValue.Key), 0.0f) ;
			float EndX		= FMath::Min(ScaleInfo.InputToLocalX(Key2_TimeValue.Key),ScaleInfo.WidgetSize.X);
			for(;StartX<EndX; StartX += StepSize)
			{
				float CurveIn = ScaleInfo.LocalXToInput(FMath::Min(StartX,EndX));
				float CurveOut = Curve->Eval(CurveIn);
				Points.Add(FVector2D(CurveIn,CurveOut));
			}
			Points.Add(FVector2D(Key2_TimeValue.Key,Key2_TimeValue.Value));

		}break;
	}

	//Transform to screen
	for(auto It = Points.CreateIterator();It;++It)
	{
		FVector2D Vec2D = *It;
		Vec2D.X = ScaleInfo.InputToLocalX(Vec2D.X);
		Vec2D.Y = ScaleInfo.OutputToLocalY(Vec2D.Y);
		*It = Vec2D;
	}
}

void SCurveEditor::PaintKeys(TSharedPtr<FCurveViewModel> CurveViewModel, FTrackScaleInfo &ScaleInfo, FSlateWindowElementList &OutDrawElements, int32 LayerId, int32 SelectedLayerId, const FGeometry &AllottedGeometry, const FSlateRect& MyCullingRect, ESlateDrawEffect DrawEffects, const FWidgetStyle &InWidgetStyle, bool bAnyCurveViewModelsSelected ) const
{
	FLinearColor KeyColor = CurveViewModel->bIsLocked ? FLinearColor(0.1f,0.1f,0.1f,1.f) : InWidgetStyle.GetColorAndOpacityTint();

	const bool bHasRichCurves = CurveOwner->HasRichCurves();

	// Iterate over each key
	ERichCurveInterpMode LastInterpMode = RCIM_Linear;
	FRealCurve* Curve = CurveViewModel->CurveInfo.CurveToEdit;
	for (auto It(Curve->GetKeyHandleIterator()); It; ++It)
	{
		FKeyHandle KeyHandle = *It;

		// Work out where it is
		FVector2D KeyLocation(
			ScaleInfo.InputToLocalX(Curve->GetKeyTime(KeyHandle)),
			ScaleInfo.OutputToLocalY(Curve->GetKeyValue(KeyHandle)));
		FVector2D KeyIconLocation = KeyLocation - (CONST_KeySize / 2);

		// Get brush
		bool IsSelected = IsKeySelected(FSelectedCurveKey(Curve,KeyHandle));
		const FSlateBrush* KeyBrush = IsSelected ? FAppStyle::GetBrush("CurveEd.CurveKeySelected") : FAppStyle::GetBrush("CurveEd.CurveKey");
		int32 LayerToUse = IsSelected ? SelectedLayerId: LayerId;

		// Fade out keys that are not selected and whose curve is not selected as well.
		FLinearColor SelectionTint = !CurveViewModel->bIsSelected && !IsSelected && bAnyCurveViewModelsSelected ? FLinearColor(1.0f,1.0f,1.0f,0.2f) : FLinearColor(1.0f,1.0f,1.0f,1.0f); 

		FSlateDrawElement::MakeBox(
			OutDrawElements,
			LayerToUse,
			AllottedGeometry.ToPaintGeometry( CONST_KeySize, FSlateLayoutTransform(KeyIconLocation) ),
			KeyBrush,
			DrawEffects,
			KeyBrush->GetTint( InWidgetStyle ) * InWidgetStyle.GetColorAndOpacityTint() * KeyColor * SelectionTint
			);

		//Handle drawing the tangent controls for curve
		bool bIsTangentSelected = false;
		bool bIsArrivalSelected = false;
		bool bIsLeaveSelected = false;
		if (bHasRichCurves)
		{
			FRichCurve* RichCurve = (FRichCurve*)Curve;
			if (IsTangentVisible(RichCurve, KeyHandle, bIsTangentSelected, bIsArrivalSelected, bIsLeaveSelected) && (RichCurve->GetKeyInterpMode(KeyHandle) == RCIM_Cubic || LastInterpMode == RCIM_Cubic))
			{
				PaintTangent(CurveViewModel, ScaleInfo, RichCurve, KeyHandle, KeyLocation, OutDrawElements, LayerId, AllottedGeometry, MyCullingRect, DrawEffects, LayerToUse, InWidgetStyle, bIsTangentSelected, bIsArrivalSelected, bIsLeaveSelected, bAnyCurveViewModelsSelected);
			}
		}

		LastInterpMode = Curve->GetKeyInterpMode(KeyHandle);
	}
}


void SCurveEditor::PaintTangent( TSharedPtr<FCurveViewModel> CurveViewModel, FTrackScaleInfo &ScaleInfo, FRichCurve* Curve, FKeyHandle KeyHandle, FVector2D KeyLocation, FSlateWindowElementList &OutDrawElements, int32 LayerId, const FGeometry &AllottedGeometry, const FSlateRect& MyCullingRect, ESlateDrawEffect DrawEffects, int32 LayerToUse, const FWidgetStyle &InWidgetStyle, bool bTangentSelected, bool bIsArrivalSelected, bool bIsLeaveSelected, bool bAnyCurveViewModelsSelected ) const
{
	FVector2D ArriveTangentLocation, LeaveTangentLocation;
	GetTangentPoints(ScaleInfo, FSelectedCurveKey(Curve,KeyHandle), ArriveTangentLocation, LeaveTangentLocation);

	FVector2D ArriveTangentIconLocation = ArriveTangentLocation - (CONST_TangentSize / 2);
	FVector2D LeaveTangentIconLocation = LeaveTangentLocation - (CONST_TangentSize / 2);

	const FSlateBrush* TangentBrush = FAppStyle::GetBrush("CurveEd.Tangent");
	const FSlateBrush* TangentBrushSelected = FAppStyle::GetBrush("CurveEd.TangentSelected");
	const FLinearColor TangentColor = FAppStyle::GetColor("CurveEd.TangentColor");
	const FLinearColor TangentColorSelected = FAppStyle::GetColor("CurveEd.TangentColorSelected");

	bool LeaveTangentSelected = bTangentSelected && bIsLeaveSelected;
	bool ArriveTangentSelected = bTangentSelected && bIsArrivalSelected;

	FLinearColor LeaveSelectionTint = !CurveViewModel->bIsSelected && !LeaveTangentSelected && bAnyCurveViewModelsSelected ? FLinearColor(1.0f,1.0f,1.0f,0.2f) : FLinearColor(1.0f,1.0f,1.0f,1.0f); 
	FLinearColor ArriveSelectionTint = !CurveViewModel->bIsSelected && !ArriveTangentSelected && bAnyCurveViewModelsSelected ? FLinearColor(1.0f,1.0f,1.0f,0.2f) : FLinearColor(1.0f,1.0f,1.0f,1.0f); 

	//Add lines from tangent control point to 'key'
	TArray<FVector2D> LinePoints;
	LinePoints.Add(FVector2D(KeyLocation));
	LinePoints.Add(FVector2D(ArriveTangentLocation));
	FSlateDrawElement::MakeLines(
		OutDrawElements,
		LayerId,
		AllottedGeometry.ToPaintGeometry(),
		LinePoints,
		DrawEffects,
		ArriveTangentSelected ? TangentColorSelected * ArriveSelectionTint : TangentColor * ArriveSelectionTint
		);

	LinePoints.Empty();
	LinePoints.Add(FVector2D(KeyLocation));
	LinePoints.Add(FVector2D(LeaveTangentLocation));
	FSlateDrawElement::MakeLines(
		OutDrawElements,
		LayerId,
		AllottedGeometry.ToPaintGeometry(),
		LinePoints,
		DrawEffects,
		LeaveTangentSelected ? TangentColorSelected * LeaveSelectionTint : TangentColor * LeaveSelectionTint
		);

	//Arrive tangent control
	FSlateDrawElement::MakeBox(
		OutDrawElements,
		LayerToUse,
		AllottedGeometry.ToPaintGeometry( CONST_TangentSize, FSlateLayoutTransform(ArriveTangentIconLocation) ),
		ArriveTangentSelected ? TangentBrushSelected : TangentBrush,
		DrawEffects,
		ArriveTangentSelected ? TangentBrushSelected->GetTint( InWidgetStyle ) * ArriveSelectionTint : TangentBrush->GetTint( InWidgetStyle ) * InWidgetStyle.GetColorAndOpacityTint() * ArriveSelectionTint
		);
	//Leave tangent control
	FSlateDrawElement::MakeBox(
		OutDrawElements,
		LayerToUse,
		AllottedGeometry.ToPaintGeometry( CONST_TangentSize, FSlateLayoutTransform(LeaveTangentIconLocation) ),
		LeaveTangentSelected ? TangentBrushSelected : TangentBrush,
		DrawEffects,
		LeaveTangentSelected ? TangentBrushSelected->GetTint( InWidgetStyle ) * LeaveSelectionTint : TangentBrush->GetTint( InWidgetStyle ) * InWidgetStyle.GetColorAndOpacityTint() * LeaveSelectionTint
		);
}


float SCurveEditor::CalcGridLineStepDistancePow2(double RawValue)
{
	return float(double(FMath::RoundUpToPowerOfTwo(uint32(RawValue*1024.0))>>1)/1024.0);
}

float SCurveEditor::GetTimeStep(FTrackScaleInfo &ScaleInfo) const
{
	const float MaxGridPixelSpacing = 150.0f;

	const float GridPixelSpacing = FMath::Min(ScaleInfo.WidgetSize.GetMin()/1.5f, MaxGridPixelSpacing);

	double MaxTimeStep = ScaleInfo.LocalXToInput(ViewMinInput.Get() + GridPixelSpacing) - ScaleInfo.LocalXToInput(ViewMinInput.Get());

	return CalcGridLineStepDistancePow2(MaxTimeStep);
}

void SCurveEditor::PaintGridLines(const FGeometry &AllottedGeometry, FTrackScaleInfo &ScaleInfo, FSlateWindowElementList &OutDrawElements, 
	int32 LayerId, const FSlateRect& MyCullingRect, ESlateDrawEffect DrawEffects )const
{
	const float MaxGridPixelSpacing = 150.0f;

	const float GridPixelSpacing = FMath::Min(ScaleInfo.WidgetSize.GetMin()/1.5f, MaxGridPixelSpacing);

	const FLinearColor GridTextColor = FLinearColor(1.0f,1.0f,1.0f, 0.75f) ;

	//Vertical grid(time)
	{
		float TimeStep = GetTimeStep(ScaleInfo);
		float ScreenStepTime = ScaleInfo.InputToLocalX(TimeStep) -  ScaleInfo.InputToLocalX(0.0f);

		if(ScreenStepTime >= 1.0f)
		{
			float StartTime = ScaleInfo.LocalXToInput(0.0f);
			TArray<FVector2D> LinePoints;
			float ScaleX = (TimeStep)/(AllottedGeometry.GetLocalSize().X);

			//draw vertical grid lines
			float StartOffset = -FMath::Fractional(StartTime / TimeStep)*ScreenStepTime;
			float Time =  ScaleInfo.LocalXToInput(StartOffset);
			for(float X = StartOffset;X< AllottedGeometry.GetLocalSize().X;X+= ScreenStepTime, Time += TimeStep)
			{
				if(SMALL_NUMBER < FMath::Abs(X)) //don't show at 0 to avoid overlapping with center axis 
				{
					LinePoints.Add(FVector2D(X, 0.0));
					LinePoints.Add(FVector2D(X, AllottedGeometry.GetLocalSize().Y));
					FSlateDrawElement::MakeLines(
						OutDrawElements,
						LayerId,
						AllottedGeometry.ToPaintGeometry(),
						LinePoints,
						DrawEffects,
						GridColor,
						false);

					//Show grid time
					if (bDrawInputGridNumbers)
					{
						FString TimeStr = FString::Printf(TEXT("%.2f"), Time);
						FSlateDrawElement::MakeText(OutDrawElements,LayerId,AllottedGeometry.MakeChild(FVector2D(1.0f, ScaleX ), FSlateLayoutTransform(FVector2D(X, 0.0))).ToPaintGeometry(),TimeStr,
							FAppStyle::GetFontStyle("CurveEd.InfoFont"), DrawEffects, GridTextColor );
					}

					LinePoints.Empty();
				}
			}
		}
	}

	//Horizontal grid(values)
	// This is only useful if the curves are visible
	if( AreCurvesVisible() )
	{
		double MaxValueStep = ScaleInfo.LocalYToOutput(0) - ScaleInfo.LocalYToOutput(GridPixelSpacing) ;
		float ValueStep = CalcGridLineStepDistancePow2(MaxValueStep);
		float ScreenStepValue = ScaleInfo.OutputToLocalY(0.0f) - ScaleInfo.OutputToLocalY(ValueStep);  
		if(ScreenStepValue >= 1.0f)
		{
			float StartValue = ScaleInfo.LocalYToOutput(0.0f);
			TArray<FVector2D> LinePoints;

			float StartOffset = FMath::Fractional(StartValue / ValueStep)*ScreenStepValue;
			float Value = ScaleInfo.LocalYToOutput(StartOffset);
			float ScaleY = (ValueStep)/(AllottedGeometry.GetLocalSize().Y);

			for(float Y = StartOffset;Y< AllottedGeometry.GetLocalSize().Y;Y+= ScreenStepValue, Value-=ValueStep)
			{
				if(SMALL_NUMBER < FMath::Abs(Y)) //don't show at 0 to avoid overlapping with center axis 
				{
					LinePoints.Add(FVector2D(0.0f, Y));
					LinePoints.Add(FVector2D(AllottedGeometry.GetLocalSize().X,Y));
					FSlateDrawElement::MakeLines(
						OutDrawElements,
						LayerId,
						AllottedGeometry.ToPaintGeometry(),
						LinePoints,
						DrawEffects,
						GridColor,
						false);

					//Show grid value
					if (bDrawOutputGridNumbers)
					{
						FString ValueStr = FString::Printf(TEXT("%.2f"), Value);
						FSlateFontInfo Font = FAppStyle::GetFontStyle("CurveEd.InfoFont");

						const TSharedRef< FSlateFontMeasure > FontMeasureService = FSlateApplication::Get().GetRenderer()->GetFontMeasureService();
						FVector2D DrawSize = FontMeasureService->Measure(ValueStr, Font);

						// draw at the start
						FSlateDrawElement::MakeText(OutDrawElements,LayerId,AllottedGeometry.MakeChild(FVector2D(ScaleY, 1.0f ), FSlateLayoutTransform(FVector2D(0.0f, Y))).ToPaintGeometry(),
							ValueStr, Font, DrawEffects, GridTextColor );

						// draw at the last since sometimes start can be hidden
						FSlateDrawElement::MakeText(OutDrawElements,LayerId,AllottedGeometry.MakeChild(FVector2D(ScaleY, 1.0f ), FSlateLayoutTransform(FVector2D(AllottedGeometry.GetLocalSize().X-DrawSize.X, Y))).ToPaintGeometry(),
							ValueStr, Font, DrawEffects, GridTextColor );
					}
					
					LinePoints.Empty();
				}
			}
		}
	}
}

void SCurveEditor::PaintMarquee(const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId) const
{
	FVector2D MarqueTopLeft(
		FMath::Min(MouseDownLocation.X, MouseMoveLocation.X),
		FMath::Min(MouseDownLocation.Y, MouseMoveLocation.Y)
		);

	FVector2D MarqueBottomRight(
		FMath::Max(MouseDownLocation.X, MouseMoveLocation.X),
		FMath::Max(MouseDownLocation.Y, MouseMoveLocation.Y)
		);

	FSlateDrawElement::MakeBox(
		OutDrawElements,
		LayerId,
		AllottedGeometry.ToPaintGeometry(MarqueBottomRight - MarqueTopLeft, FSlateLayoutTransform(MarqueTopLeft)),
		FAppStyle::GetBrush(TEXT("MarqueeSelection"))
		);
}

float SCurveEditor::GetInputNumericEntryBoxDelta() const
{
	return bInputSnappingEnabled.Get() ? InputSnap.Get() : 0;
}

float SCurveEditor::GetOutputNumericEntryBoxDelta() const
{
	return bOutputSnappingEnabled.Get() ? OutputSnap.Get() : 0;
}

void SCurveEditor::SetCurveOwner(FCurveOwnerInterface* InCurveOwner, bool bCanEdit)
{
	if(InCurveOwner != CurveOwner)
	{
		EmptyAllSelection();
	}

	GradientViewer->SetCurveOwner(InCurveOwner);

	CurveOwner = InCurveOwner;
	bCanEditTrack = bCanEdit;

	if (bAreCurvesVisible.IsBound() == false || SetAreCurvesVisibleHandler.IsBound() == false)
	{
		bAreCurvesVisible = !IsLinearColorCurve();
	}

	bIsGradientEditorVisible = IsLinearColorCurve();

	CurveViewModels.Empty();
	if(CurveOwner != NULL)
	{
		for (const FRichCurveEditInfo& CurveInfo : CurveOwner->GetCurves())
		{
			CurveViewModels.Add(TSharedPtr<FCurveViewModel>(new FCurveViewModel(CurveInfo, CurveOwner->GetCurveColor(CurveInfo), !bCanEdit)));
		}
		if (bCanEdit)
		{
			CurveOwner->MakeTransactional();
		}
	}

	ValidateSelection();

	if (GetAutoFrame())
	{
		if( bZoomToFitVertical )
		{
			ZoomToFitVertical();
		}

		if ( bZoomToFitHorizontal )
		{
			ZoomToFitHorizontal();
		}
	}

	CurveSelectionWidget.Pin()->SetContent(CreateCurveSelectionWidget());
}

void SCurveEditor::RegisterToPropertyChangedEvent(const TSharedPtr<IPropertyHandle>& InRootPropertyHandle)
{
	RootPropertyHandleWeak = InRootPropertyHandle.ToWeakPtr();
	const auto OnChildPropertyChanged = TDelegate<void(const FPropertyChangedEvent&)>::CreateSP(this, &SCurveEditor::OnRootPropertyChanged);

	if (const TSharedPtr<IPropertyHandle> RootPropertyHandle = RootPropertyHandleWeak.Pin())
	{
		RootPropertyHandle->SetOnChildPropertyValueChangedWithData(OnChildPropertyChanged);
	}
}

void SCurveEditor::SetZoomToFit(bool bNewZoomToFitVertical, bool bNewZoomToFitHorizontal)
{
	bZoomToFitVertical = bNewZoomToFitVertical;
	bZoomToFitHorizontal = bNewZoomToFitHorizontal;
}

void SCurveEditor::SetRequireFocusToZoom(bool bInRequireFocusToZoom)
{
	bRequireFocusToZoom = bInRequireFocusToZoom;
}

TOptional<bool> SCurveEditor::OnQueryShowFocus(const EFocusCause InFocusCause) const
{
	if (bRequireFocusToZoom)
	{
		// Enable showing a focus rectangle when the widget has keyboard focus
		return TOptional<bool>(true);
	}
	return TOptional<bool>();
}

FCurveOwnerInterface* SCurveEditor::GetCurveOwner() const
{
	return CurveOwner;
}

FRealCurve* SCurveEditor::GetCurve(int32 CurveIndex) const
{
	if(CurveIndex < CurveViewModels.Num())
	{
		return CurveViewModels[CurveIndex]->CurveInfo.CurveToEdit;
	}
	return NULL;
}

void SCurveEditor::DeleteSelectedKeys()
{
	const FScopedTransaction Transaction(LOCTEXT("CurveEditor_RemoveKeys", "Delete Key(s)"));
	CurveOwner->ModifyOwner();
	TSet<FRealCurve*> ChangedCurves;

	// While there are still keys
	while(SelectedKeys.Num() > 0)
	{
		// Pull one out of the selected set
		FSelectedCurveKey Key = SelectedKeys.Pop();
		if(IsValidCurve(Key.Curve))
		{
			// Remove from the curve
			Key.Curve->DeleteKey(Key.KeyHandle);
			ChangedCurves.Add(Key.Curve);
		}
	}

	TArray<FRichCurveEditInfo> ChangedCurveEditInfos;
	for (auto CurveViewModel : CurveViewModels)
	{
		if (ChangedCurves.Contains(CurveViewModel->CurveInfo.CurveToEdit))
		{
			ChangedCurveEditInfos.Add(CurveViewModel->CurveInfo);
		}
	}

	CurveOwner->OnCurveChanged(ChangedCurveEditInfos);
}

FReply SCurveEditor::OnMouseButtonDown( const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent)
{
	// End any transactions that weren't ended cleanly
	EndDragTransaction();

	const bool bLeftMouseButton = InMouseEvent.GetEffectingButton() == EKeys::LeftMouseButton;
	const bool bMiddleMouseButton = InMouseEvent.GetEffectingButton() == EKeys::MiddleMouseButton;
	const bool bRightMouseButton = InMouseEvent.GetEffectingButton() == EKeys::RightMouseButton;

	DragState = EDragState::PreDrag;
	MovementAxisLock = EMovementAxisLock::None;

	if (bLeftMouseButton || bMiddleMouseButton || bRightMouseButton)
	{
		MouseDownLocation = InMyGeometry.AbsoluteToLocal(InMouseEvent.GetScreenSpacePosition());

		// Set keyboard focus to this so that selected text box doesn't try to apply to newly selected keys
		if(!HasKeyboardFocus())
		{
			FSlateApplication::Get().SetKeyboardFocus(SharedThis(this), EFocusCause::SetDirectly);
		}

		// Always capture mouse if we left or right click on the widget
		return FReply::Handled().CaptureMouse(SharedThis(this));
	}

	return FReply::Unhandled();
}

void SCurveEditor::AddNewKey(FGeometry InMyGeometry, FVector2D ScreenPosition, TSharedPtr<TArray<TSharedPtr<FCurveViewModel>>> CurvesToAddKeysTo, bool bAddKeysInline)
{
	const FScopedTransaction Transaction(LOCTEXT("CurveEditor_AddKey", "Add Key(s)"));
	CurveOwner->ModifyOwner();
	TArray<FRichCurveEditInfo> ChangedCurveEditInfos;
	for (TSharedPtr<FCurveViewModel> CurveViewModel : *CurvesToAddKeysTo)
	{
		if (!CurveViewModel->bIsLocked)
		{
			FRealCurve* SelectedCurve = CurveViewModel->CurveInfo.CurveToEdit;
			if (IsValidCurve(SelectedCurve))
			{
				FTrackScaleInfo ScaleInfo(ViewMinInput.Get(), ViewMaxInput.Get(), ViewMinOutput.Get(), ViewMaxOutput.Get(), InMyGeometry.GetLocalSize());

				FVector2D LocalClickPos = InMyGeometry.AbsoluteToLocal(ScreenPosition);

				float Input = ScaleInfo.LocalXToInput(LocalClickPos.X);
				float Output;
				if (bAddKeysInline)
			{
					Output = SelectedCurve->Eval(Input);
				}
				else
				{
					Output = ScaleInfo.LocalYToOutput(LocalClickPos.Y);
				}
				FVector2D NewKeyLocation = SnapLocation(FVector2D(Input, Output));
				FKeyHandle NewKeyHandle = SelectedCurve->AddKey(NewKeyLocation.X, NewKeyLocation.Y);

				EmptyAllSelection();
				AddToKeySelection(FSelectedCurveKey(SelectedCurve, NewKeyHandle));
				ChangedCurveEditInfos.Add(CurveViewModel->CurveInfo);
			}
		}
	}

	if (ChangedCurveEditInfos.Num() > 0)
	{
		CurveOwner->OnCurveChanged(ChangedCurveEditInfos);
	}
}

void SCurveEditor::OnMouseCaptureLost(const FCaptureLostEvent& CaptureLostEvent)
{
	// if we began a drag transaction we need to finish it to make sure undo doesn't get out of sync
	if (DragState == EDragState::DragKey || DragState == EDragState::FreeDrag || DragState == EDragState::DragTangent)
	{
		EndDragTransaction();
	}
	DragState = EDragState::None;
}

FReply SCurveEditor::OnMouseButtonUp( const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent )
{
	if (this->HasMouseCapture())
	{
		if (DragState == EDragState::PreDrag)
		{
			// If the user didn't start dragging, handle the mouse operation as a click.
			ProcessClick(InMyGeometry, InMouseEvent);
		}
		else
		{
			EndDrag(InMyGeometry, InMouseEvent);
		}
		return FReply::Handled().ReleaseMouseCapture();
	}
	return FReply::Unhandled();
}

void ClampViewRangeToDataIfBound( float& NewViewMin, float& NewViewMax, const TAttribute< TOptional<float> > & DataMin, const TAttribute< TOptional<float> > & DataMax, const float ViewRange)
{
	// if we have data bound
	const TOptional<float> & Min = DataMin.Get();
	const TOptional<float> & Max = DataMax.Get();
	if ( Min.IsSet() && NewViewMin < Min.GetValue())
	{
		// if we have min data set
		NewViewMin = Min.GetValue();
		NewViewMax = ViewRange;
	}
	else if ( Max.IsSet() && NewViewMax > Max.GetValue() )
	{
		// if we have min data set
		NewViewMin = Max.GetValue() - ViewRange;
		NewViewMax = Max.GetValue();
	}
}

FReply SCurveEditor::OnMouseMove( const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent )
{
	UpdateCurveToolTip(InMyGeometry, InMouseEvent);

	FRealCurve* Curve = GetCurve(0);
	if( Curve != NULL && this->HasMouseCapture())
	{
		if (DragState == EDragState::PreDrag)
		{
			TryStartDrag(InMyGeometry, InMouseEvent);
		}
		if (DragState != EDragState::None)
		{
			ProcessDrag(InMyGeometry, InMouseEvent);
		}
		MouseMoveLocation = InMyGeometry.AbsoluteToLocal(InMouseEvent.GetScreenSpacePosition());
		return FReply::Handled();
	}
	return FReply::Unhandled();
}

void SCurveEditor::UpdateCurveToolTip(const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent)
{
	if (Settings->GetShowCurveEditorCurveToolTips())
	{
		TSharedPtr<FCurveViewModel> HoveredCurve = HitTestCurves(InMyGeometry, InMouseEvent);
		//Display the tooltip only when the curve is visible
		if (HoveredCurve.IsValid() && HoveredCurve->bIsVisible)
		{
			FTrackScaleInfo ScaleInfo(ViewMinInput.Get(), ViewMaxInput.Get(), ViewMinOutput.Get(), ViewMaxOutput.Get(), InMyGeometry.GetLocalSize());
			const FVector2D HitPosition = InMyGeometry.AbsoluteToLocal(InMouseEvent.GetScreenSpacePosition());
			float Time = ScaleInfo.LocalXToInput(HitPosition.X);
			float Value = HoveredCurve->CurveInfo.CurveToEdit->Eval(Time);

			FNumberFormattingOptions FormattingOptions;
			FormattingOptions.MaximumFractionalDigits = 2;
			CurveToolTipNameText = FText::FromName(HoveredCurve->CurveInfo.CurveName);
			CurveToolTipOutputText = FText::Format(LOCTEXT("CurveToolTipValueFormat", "{0}: {1}"), OutputAxisName, FText::AsNumber(Value, &FormattingOptions));

			if (ShowTimeInFrames())
			{
				CurveToolTipInputText = FText::Format(LOCTEXT("CurveToolTipFrameFormat", "{0}: {1}"), GetInputAxisName(), FText::AsNumber(TimeToFrame(Time)));
			}
			else
			{
				CurveToolTipInputText = FText::Format(LOCTEXT("CurveToolTipTimeFormat", "{0}: {1}"), GetInputAxisName(), FText::AsNumber(Time, &FormattingOptions));
			}

			if (CurveToolTip.IsValid() == false)
			{
				SetToolTip(
					SAssignNew(CurveToolTip, SToolTip)
					.BorderImage( FCoreStyle::Get().GetBrush( "ToolTip.BrightBackground" ) )
					[
						SNew(SVerticalBox)
						+ SVerticalBox::Slot()
						[
							SNew(STextBlock)
							.Text(this, &SCurveEditor::GetCurveToolTipNameText)
							.Font(FCoreStyle::Get().GetFontStyle("ToolTip.LargerFont"))
							.ColorAndOpacity( FLinearColor::Black)
						]
						+ SVerticalBox::Slot()
						[
							SNew(STextBlock)
							.Text(this, &SCurveEditor::GetCurveToolTipInputText)
							.Font(FCoreStyle::Get().GetFontStyle("ToolTip.LargerFont"))
							.ColorAndOpacity(FLinearColor::Black)
						]
						+ SVerticalBox::Slot()
						[
							SNew(STextBlock)
							.Text(this, &SCurveEditor::GetCurveToolTipOutputText)
							.Font(FCoreStyle::Get().GetFontStyle("ToolTip.LargerFont"))
							.ColorAndOpacity(FLinearColor::Black)
						]
					]);
			}
		}
		else
		{
			CurveToolTip.Reset();
			SetToolTip(CurveToolTip);
		}
	}
}

FReply SCurveEditor::OnMouseWheel(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent)
{
	if (!bRequireFocusToZoom || HasKeyboardFocus())
	{
		ZoomView(FVector2D(MouseEvent.GetWheelDelta(), MouseEvent.GetWheelDelta()));
		return FReply::Handled();
	}
	return FReply::Unhandled();
}

void SCurveEditor::ZoomView(FVector2D Delta)
{
	const FVector2D ZoomDelta = -0.1f * Delta;

	if (bAllowZoomOutput)
	{
		const float OutputViewSize = ViewMaxOutput.Get() - ViewMinOutput.Get();
		const float OutputChange = OutputViewSize * ZoomDelta.Y;

		const float NewMinOutput = (ViewMinOutput.Get() - (OutputChange * 0.5f));
		const float NewMaxOutput = (ViewMaxOutput.Get() + (OutputChange * 0.5f));

		SetOutputMinMax(NewMinOutput, NewMaxOutput);
	}

	{
		const float InputViewSize = ViewMaxInput.Get() - ViewMinInput.Get();
		const float InputChange = InputViewSize * ZoomDelta.X;

		const float NewMinInput = ViewMinInput.Get() - (InputChange * 0.5f);
		const float NewMaxInput = ViewMaxInput.Get() + (InputChange * 0.5f);

		SetInputMinMax(NewMinInput, NewMaxInput);
	}
}

FReply SCurveEditor::OnKeyDown( const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent )
{
	if (InKeyEvent.GetKey() == EKeys::Platform_Delete && SelectedKeys.Num() != 0)
	{
		DeleteSelectedKeys();
		return FReply::Handled();
	}
	else
	{
		if( Commands->ProcessCommandBindings( InKeyEvent ) )
		{
			return FReply::Handled();
		}
		return FReply::Unhandled();
	}
}

void SCurveEditor::TryStartDrag(const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent)
{
	const bool bLeftMouseButton = InMouseEvent.IsMouseButtonDown(EKeys::LeftMouseButton);
	const bool bMiddleMouseButton = InMouseEvent.IsMouseButtonDown(EKeys::MiddleMouseButton);
	const bool bRightMouseButton = InMouseEvent.IsMouseButtonDown(EKeys::RightMouseButton);
	const bool bControlDown = InMouseEvent.IsControlDown();
	const bool bShiftDown = InMouseEvent.IsShiftDown();
	const bool bAltDown = InMouseEvent.IsAltDown();

	FVector2D MousePosition = InMyGeometry.AbsoluteToLocal(InMouseEvent.GetScreenSpacePosition());
	FVector2D DragVector = MousePosition - MouseDownLocation;
	if (DragVector.SizeSquared() >= FMath::Square(DragThreshold))
	{
		if (bShiftDown)
		{
			if(FMath::Abs(MousePosition.X - MouseDownLocation.X) > FMath::Abs(MousePosition.Y - MouseDownLocation.Y))
			{
				MovementAxisLock = EMovementAxisLock::AxisLock_Horizontal;
			}
			else
			{
				MovementAxisLock = EMovementAxisLock::AxisLock_Vertical;
			}
		}

		if (bLeftMouseButton)
		{
			// Check if we should start dragging keys.
			FSelectedCurveKey HitKey = HitTestKeys(InMyGeometry, InMyGeometry.LocalToAbsolute(MouseDownLocation));
			if (HitKey.IsValid())
			{
				EmptyTangentSelection();

				if (!IsKeySelected(HitKey))
				{
					if (!bControlDown)
					{
						EmptyKeySelection();
					}
					AddToKeySelection(HitKey);
				}

				BeginDragTransaction();
				DragState = EDragState::DragKey;
				DraggedKeyHandle = HitKey.KeyHandle;
				PreDragKeyLocations.Empty();
				for (auto SelectedKey : SelectedKeys)
				{
					PreDragKeyLocations.Add(SelectedKey.KeyHandle, FVector2D
					(
						SelectedKey.Curve->GetKeyTime(SelectedKey.KeyHandle),
						SelectedKey.Curve->GetKeyValue(SelectedKey.KeyHandle)
					));
				}
			}
			else
			{
				// Check if we should start dragging a tangent.
				FSelectedTangent Tangent = HitTestCubicTangents(InMyGeometry, InMyGeometry.LocalToAbsolute(MouseDownLocation));
				if (Tangent.IsValid())
				{
					EmptyKeySelection();

					if (!IsTangentSelected(Tangent))
					{
						if (!bControlDown)
						{
							EmptyTangentSelection();
						}
						AddToTangentSelection(Tangent);
					}

					BeginDragTransaction();
					DragState = EDragState::DragTangent;
					PreDragTangents.Empty();
					for (auto SelectedTangent : SelectedTangents)
					{
						FRichCurve* Curve = (FRichCurve*)SelectedTangent.Key.Curve;
						FKeyHandle KeyHandle = SelectedTangent.Key.KeyHandle;

						float ArriveTangent = Curve->GetKey(KeyHandle).ArriveTangent;
						float LeaveTangent = Curve->GetKey(KeyHandle).LeaveTangent;

						PreDragTangents.Add(KeyHandle, FVector2D(ArriveTangent, LeaveTangent));
					}
				}
				else
				{
					// Otherwise if the user left clicked on nothing and start a marquee select.
					DragState = EDragState::MarqueeSelect;
				}
			}
		}
		else if (bMiddleMouseButton)
		{
			if (bAltDown)
			{
				DragState = EDragState::Pan;
			}
			else if (SelectedTangents.Num())
			{
				BeginDragTransaction();
				DragState = EDragState::DragTangent;
				PreDragTangents.Empty();
				for (auto SelectedTangent : SelectedTangents)
				{
					FRichCurve* Curve = (FRichCurve*)SelectedTangent.Key.Curve;
					FKeyHandle KeyHandle = SelectedTangent.Key.KeyHandle;

					float ArriveTangent = Curve->GetKey(KeyHandle).ArriveTangent;
					float LeaveTangent = Curve->GetKey(KeyHandle).LeaveTangent;

					PreDragTangents.Add(KeyHandle, FVector2D(ArriveTangent, LeaveTangent));
				}
			}
			else if (SelectedKeys.Num())
			{
				BeginDragTransaction();
				DragState = EDragState::FreeDrag;
				PreDragKeyLocations.Empty();
				for (auto selectedKey : SelectedKeys)
				{
					PreDragKeyLocations.Add(selectedKey.KeyHandle, FVector2D
					(
						selectedKey.Curve->GetKeyTime(selectedKey.KeyHandle),
						selectedKey.Curve->GetKeyValue(selectedKey.KeyHandle)
					));
				}
			}
		}
		else if (bRightMouseButton)
		{
			if (bAltDown)
			{
				DragState = EDragState::Zoom;
			}
			else
			{
				DragState = EDragState::Pan;
			}
		}
		else
		{
			DragState = EDragState::None;
		}
	}
}

/* Given a tangent value for a key, calculates the 2D delta vector from that key in curve space */
static inline FVector2D CalcTangentDir(float Tangent)
{
	const float Angle = FMath::Atan(Tangent);
	return FVector2D( FMath::Cos(Angle), -FMath::Sin(Angle) );
}

/*Given a 2d delta vector in curve space, calculates a tangent value */
static inline float CalcTangent(const FVector2D& HandleDelta)
{
	// Ensure X is positive and non-zero.
	// Tangent is gradient of handle.
	return HandleDelta.Y / FMath::Max<double>(HandleDelta.X, KINDA_SMALL_NUMBER);
}

void SCurveEditor::ProcessDrag(const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent)
{
	FTrackScaleInfo ScaleInfo(ViewMinInput.Get(), ViewMaxInput.Get(), ViewMinOutput.Get(), ViewMaxOutput.Get(), InMyGeometry.GetLocalSize());
	FVector2D ScreenDelta = InMouseEvent.GetCursorDelta();

	FVector2D InputDelta;
	InputDelta.X = ScreenDelta.X / ScaleInfo.PixelsPerInput;
	InputDelta.Y = -ScreenDelta.Y / ScaleInfo.PixelsPerOutput;

	if (DragState == EDragState::DragKey)
	{
		FVector2D MousePosition = InMyGeometry.AbsoluteToLocal(InMouseEvent.GetScreenSpacePosition());
		FVector2D NewLocation = FVector2D(ScaleInfo.LocalXToInput(MousePosition.X), ScaleInfo.LocalYToOutput(MousePosition.Y));
		FVector2D SnappedNewLocation = SnapLocation(NewLocation);
		FVector2D Delta = SnappedNewLocation - PreDragKeyLocations[DraggedKeyHandle];

		MoveSelectedKeys(Delta);
	}
	else if (DragState == EDragState::FreeDrag)
	{
		FVector2D MousePosition = InMyGeometry.AbsoluteToLocal(InMouseEvent.GetScreenSpacePosition());
		FVector2D NewLocation = FVector2D(ScaleInfo.LocalXToInput(MousePosition.X), ScaleInfo.LocalYToOutput(MousePosition.Y));
		FVector2D Delta = NewLocation - FVector2D(ScaleInfo.LocalXToInput(MouseDownLocation.X), ScaleInfo.LocalYToOutput(MouseDownLocation.Y));

		MoveSelectedKeys(Delta);
	}
	else if (DragState == EDragState::DragTangent)
	{
		FVector2D MousePositionScreen = InMyGeometry.AbsoluteToLocal(InMouseEvent.GetScreenSpacePosition());
		FVector2D MouseDownPositionScreen = MouseDownLocation;
		MoveTangents(ScaleInfo, MousePositionScreen - MouseDownPositionScreen);
	}
	else if (DragState == EDragState::Pan)
	{
		if (MovementAxisLock == EMovementAxisLock::AxisLock_Horizontal)
		{
			InputDelta.Y = 0;
		}
		else if (MovementAxisLock == EMovementAxisLock::AxisLock_Vertical)
		{
			InputDelta.X = 0;
		}

		// Output is not clamped.
		const float NewMinOutput = (ViewMinOutput.Get() - InputDelta.Y);
		const float NewMaxOutput = (ViewMaxOutput.Get() - InputDelta.Y);

		SetOutputMinMax(NewMinOutput, NewMaxOutput);

		// Input maybe clamped if DataMinInput or DataMaxOutput was set.
		float NewMinInput = ViewMinInput.Get() - InputDelta.X;
		float NewMaxInput = ViewMaxInput.Get() - InputDelta.X;
		ClampViewRangeToDataIfBound(NewMinInput, NewMaxInput, DataMinInput, DataMaxInput, ScaleInfo.ViewInputRange);

		SetInputMinMax(NewMinInput, NewMaxInput);
	}
	else if (DragState == EDragState::Zoom)
	{
		FVector2D Delta = FVector2D(ScreenDelta.X * 0.05f, ScreenDelta.X * 0.05f);

		if (MovementAxisLock == EMovementAxisLock::AxisLock_Horizontal)
		{
			Delta.Y = 0;
		}
		else if (MovementAxisLock == EMovementAxisLock::AxisLock_Vertical)
		{
			Delta.X = 0;
			Delta.Y = -ScreenDelta.Y * 0.1f;
		}

		ZoomView(Delta);
	}
}

void SCurveEditor::EndDrag(const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent)
{
	const bool bControlDown = InMouseEvent.IsControlDown();
	const bool bShiftDown = InMouseEvent.IsShiftDown();

	if (DragState == EDragState::DragKey || DragState == EDragState::FreeDrag || DragState == EDragState::DragTangent)
	{
		EndDragTransaction();
	}
	else if (DragState == EDragState::MarqueeSelect)
	{
		FVector2D MarqueTopLeft
		(
			FMath::Min(MouseDownLocation.X, MouseMoveLocation.X),
			FMath::Min(MouseDownLocation.Y, MouseMoveLocation.Y)
			);

		FVector2D MarqueBottomRight
		(
			FMath::Max(MouseDownLocation.X, MouseMoveLocation.X),
			FMath::Max(MouseDownLocation.Y, MouseMoveLocation.Y)
			);

		TArray<FSelectedTangent> SelectedCurveTangents = GetEditableTangentsWithinMarquee(InMyGeometry, MarqueTopLeft, MarqueBottomRight);

		TArray<FSelectedCurveKey> SelectedCurveKeys = GetEditableKeysWithinMarquee(InMyGeometry, MarqueTopLeft, MarqueBottomRight);

		if (!bControlDown && !bShiftDown)
		{
			EmptyAllSelection();
		}

		if (SelectedCurveKeys.Num())
		{
			EmptyTangentSelection();

			for (auto SelectedCurveKey : SelectedCurveKeys)
			{			
				if (IsKeySelected(SelectedCurveKey))
				{
					RemoveFromKeySelection(SelectedCurveKey);
				}
				else
				{
					AddToKeySelection(SelectedCurveKey);
				}
			}
		}

		if (!SelectedCurveKeys.Num())
		{
			EmptyKeySelection();

			for (auto SelectedCurveTangent : SelectedCurveTangents)
			{			
				if (IsTangentSelected(SelectedCurveTangent))
				{
					RemoveFromTangentSelection(SelectedCurveTangent);
				}
				else
				{
					AddToTangentSelection(SelectedCurveTangent);
				}
			}
		}
	}
	DragState = EDragState::None;
	MovementAxisLock = EMovementAxisLock::None;
}

void SCurveEditor::ProcessClick(const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent)
{
	const bool bLeftMouseButton = InMouseEvent.GetEffectingButton() == EKeys::LeftMouseButton;
	const bool bRightMouseButton = InMouseEvent.GetEffectingButton() == EKeys::RightMouseButton;
	const bool bControlDown = InMouseEvent.IsControlDown();
	const bool bShiftDown = InMouseEvent.IsShiftDown();

	FSelectedCurveKey HitKey = HitTestKeys(InMyGeometry, InMouseEvent.GetScreenSpacePosition());
	FSelectedTangent HitTangent = HitTestCubicTangents(InMyGeometry, InMouseEvent.GetScreenSpacePosition());

	if (bLeftMouseButton)
	{
		// If the user left clicked a key, update selection based on modifier key state.
		if (HitKey.IsValid())
		{
			EmptyTangentSelection();

			if (!IsKeySelected(HitKey))
			{
				if (!bControlDown && !bShiftDown)
				{
					EmptyAllSelection();
				}
				AddToKeySelection(HitKey);
			}
			else if (bControlDown)
			{
				RemoveFromKeySelection(HitKey);
			}
		}
		else if (HitTangent.IsValid())
		{
			EmptyKeySelection();

			if (!IsTangentSelected(HitTangent))
			{
				if (!bControlDown && !bShiftDown)
				{
					EmptyAllSelection();
				}
				AddToTangentSelection(HitTangent);
			}
			else if (bControlDown)
			{
				RemoveFromTangentSelection(HitTangent);
			}
		}
		else
		{
			// If the user didn't click a key, add a new one if shift is held down, or try to select a curve.
			if (bShiftDown && IsEditingEnabled())
			{
				TSharedPtr<TArray<TSharedPtr<FCurveViewModel>>> CurvesToAddKeysTo = MakeShareable(new TArray<TSharedPtr<FCurveViewModel>>());
				TSharedPtr<FCurveViewModel> HoveredCurve = HitTestCurves(InMyGeometry, InMouseEvent);
				bool bAddKeysInline;
				//To snap a point on the hovered curve the curve must be visible and unlock
				if (HoveredCurve.IsValid() && !HoveredCurve->bIsLocked && HoveredCurve->bIsVisible)
				{
					CurvesToAddKeysTo->Add(HoveredCurve);
					bAddKeysInline = true;
				}
				else
				{
					//Add all unlock curves in the editable array
					for (auto CurveViewModel : CurveViewModels)
					{
						if (!CurveViewModel->bIsLocked)
						{
							CurvesToAddKeysTo->Add(CurveViewModel);
						}
					}

					//If linear color curve and no show curve, always insert inline
					//If the user is holding shift-ctrl we snap all curve to the mouse position. (false value)
					//If the user is holding shift we snap to mouse only if there is only one editable curve. (false value)
					//In all other case we add key directly on the curve. (true value)
					bAddKeysInline = (IsLinearColorCurve() && !bAreCurvesVisible.Get()) || ((!bControlDown) && (CurvesToAddKeysTo->Num() != 1));
				}
				AddNewKey(InMyGeometry, InMouseEvent.GetScreenSpacePosition(), CurvesToAddKeysTo, bAddKeysInline);
			}
			else
			{
				// clicking on background clears all selection
				EmptyAllSelection();
			}
		}
	}
	else if (bRightMouseButton)
	{
		// If the user right clicked, handle opening context menus.
		if (HitKey.IsValid())
		{
			// Make sure key is selected in readiness for context menu
			EmptyTangentSelection();

			if (!IsKeySelected(HitKey))
			{
				EmptyAllSelection();
				AddToKeySelection(HitKey);
			}
			PushKeyMenu(InMyGeometry, InMouseEvent);
		}
		else if (HitTangent.IsValid())
		{
			// Make sure key is selected in readiness for context menu
			EmptyKeySelection();

			if (!IsTangentSelected(HitTangent))
			{
				EmptyAllSelection();
				AddToTangentSelection(HitTangent);
			}
			PushKeyMenu(InMyGeometry, InMouseEvent);
		}
		else
		{
			CreateContextMenu(InMyGeometry, InMouseEvent);
		}
	}
}

TOptional<float> SCurveEditor::OnGetTime() const
{
	TOptional<float> Time;

	// Return the time if all selected keys have the same time, otherwise return an unset value
	if (SelectedKeys.Num() > 0)
	{
		Time = GetKeyTime(SelectedKeys[0]);
		for (int32 i = 1; i < SelectedKeys.Num(); i++)
		{
			TOptional<float> NewTime = GetKeyTime(SelectedKeys[i]);
			bool bAreEqual = ((!Time.IsSet() && !NewTime.IsSet()) || (Time.IsSet() && NewTime.IsSet() && Time.GetValue() == NewTime.GetValue()));
			if (!bAreEqual)
			{
				return TOptional<float>();
			}
		}
	}

	return Time;
}

void SCurveEditor::OnTimeComitted(float NewTime, ETextCommit::Type CommitType)
{
	// Don't digest the number if we just clicked away from the pop-up
	if ( !bIsUsingSlider && ((CommitType == ETextCommit::OnEnter) || ( CommitType == ETextCommit::OnUserMovedFocus )) )
	{
		for(FSelectedCurveKey Key : SelectedKeys)
		{
			UpdateCurveTimeSingleKey(Key, NewTime);
		}

		FSlateApplication::Get().DismissAllMenus();
	}
}

void SCurveEditor::OnTimeChanged(float NewTime)
{
	if ( bIsUsingSlider )
	{
		for (FSelectedCurveKey Key : SelectedKeys)
		{
			UpdateCurveTimeSingleKey(Key, NewTime);
		}
	}
}

TOptional<int32> SCurveEditor::OnGetTimeInFrames() const
{
	TOptional<float> Time;

	// Return the time in frames if all selected keys have the same time, otherwise return an unset value
	if (SelectedKeys.Num() > 0)
	{
		Time = GetKeyTime(SelectedKeys[0]);
		for (int32 i = 1; i < SelectedKeys.Num(); i++)
		{
			TOptional<float> NewTime = GetKeyTime(SelectedKeys[i]);
			bool bAreEqual = ((!Time.IsSet() && !NewTime.IsSet()) || (Time.IsSet() && NewTime.IsSet() && Time.GetValue() == NewTime.GetValue()));
			if (!bAreEqual)
			{
				return TOptional<int32>();
			}
		}
	}

	if (Time.IsSet())
	{
		return TOptional<int32>(TimeToFrame(Time.GetValue()));
	}

	return TOptional<int32>();
}

void SCurveEditor::OnTimeInFramesComitted(int32 NewFrame, ETextCommit::Type CommitType)
{
	// Don't digest the number if we just clicked away from the pop-up
	if ( !bIsUsingSlider && ((CommitType == ETextCommit::OnEnter) || ( CommitType == ETextCommit::OnUserMovedFocus )) )
	{
		for (FSelectedCurveKey Key : SelectedKeys)
		{
			UpdateCurveTimeSingleKey(Key, NewFrame);
		}

		FSlateApplication::Get().DismissAllMenus();
	}
}

void SCurveEditor::OnTimeInFramesChanged(int32 NewFrame)
{
	if ( bIsUsingSlider )
	{
		for (FSelectedCurveKey Key : SelectedKeys)
		{
			UpdateCurveTimeSingleKey(Key, NewFrame);
		}
	}
}

void SCurveEditor::UpdateCurveTimeSingleKey(FSelectedCurveKey Key, float NewTime, bool bSetFromFrame)
{
	// If the curve is valid and doesn't already have a key at that time
	if (IsValidCurve(Key.Curve))
	{
		if (!Key.Curve->KeyExistsAtTime(NewTime))
		{
			FText TransactionText = bSetFromFrame ? LOCTEXT("CurveEditor_NewFrame", "New Frame Entered") : LOCTEXT("CurveEditor_NewTime", "New Time Entered");
			const FScopedTransaction Transaction(TransactionText);
			CurveOwner->ModifyOwner();
			Key.Curve->SetKeyTime(Key.KeyHandle, NewTime);
			TArray<FRichCurveEditInfo> ChangedCurveEditInfos;
			ChangedCurveEditInfos.Add(GetViewModelForCurve(Key.Curve)->CurveInfo);
			CurveOwner->OnCurveChanged(ChangedCurveEditInfos);
		}
		// if the existing key is not this key
		else if (Key.Curve->FindKey(NewTime) != Key.KeyHandle)
		{
			LogAndToastCurveTimeWarning(Key.Curve);
		}
	}
}

void SCurveEditor::UpdateCurveTimeSingleKey(FSelectedCurveKey Key, int32 NewFrame)
{
	UpdateCurveTimeSingleKey(Key, FrameToTime(NewFrame), true);
}

void SCurveEditor::LogAndToastCurveTimeWarning(FRealCurve* Curve)
{
	FText Error = FText::Format(LOCTEXT("KeyTimeCollision","A key on {0} could not be moved because there was already a key at that time."), FText::FromName(GetViewModelForCurve(Curve)->CurveInfo.CurveName));
	FNotificationInfo Info(Error);
	Info.ExpireDuration = 5.0f;
	FSlateNotificationManager::Get().AddNotification(Info);

	UE_LOG(LogCurveEditor, Warning, TEXT("%s"), *Error.ToString());
}

TOptional<float> SCurveEditor::OnGetValue() const
{
	TOptional<float> Value;

	// Return the value string if all selected keys have the same output string, otherwise empty
	if ( SelectedKeys.Num() > 0 )
	{
		Value = GetKeyValue(SelectedKeys[0]);
		for ( int32 i=1; i < SelectedKeys.Num(); i++ )
		{
			TOptional<float> NewValue = GetKeyValue(SelectedKeys[i]);
			bool bAreEqual = ( ( !Value.IsSet() && !NewValue.IsSet() ) || ( Value.IsSet() && NewValue.IsSet() && Value.GetValue() == NewValue.GetValue() ) );
			if ( !bAreEqual )
			{
				return TOptional<float>();
			}
		}
	}

	return Value;
}

void SCurveEditor::OnValueComitted(float NewValue, ETextCommit::Type CommitType)
{
	// Don't digest the number if we just clicked away from the popup
	if ( !bIsUsingSlider && ((CommitType == ETextCommit::OnEnter) || ( CommitType == ETextCommit::OnUserMovedFocus )) )
	{
		const FScopedTransaction Transaction( LOCTEXT( "CurveEditor_NewValue", "New Value Entered" ) );
		CurveOwner->ModifyOwner();
		TSet<FRealCurve*> ChangedCurves;

		// Iterate over selected set
		for ( int32 i=0; i < SelectedKeys.Num(); i++ )
		{
			auto Key = SelectedKeys[i];
			if ( IsValidCurve(Key.Curve) )
			{
				// Fill in each element of this key
				Key.Curve->SetKeyValue(Key.KeyHandle, NewValue);
				ChangedCurves.Add(Key.Curve);
			}
		}

		TArray<FRichCurveEditInfo> ChangedCurveEditInfos;
		for (auto CurveViewModel : CurveViewModels)
		{
			if (ChangedCurves.Contains(CurveViewModel->CurveInfo.CurveToEdit))
			{
				ChangedCurveEditInfos.Add(CurveViewModel->CurveInfo);
			}
		}
		CurveOwner->OnCurveChanged(ChangedCurveEditInfos);

		FSlateApplication::Get().DismissAllMenus();
	}
}

void SCurveEditor::OnValueChanged(float NewValue)
{
	if ( bIsUsingSlider )
	{
		const FScopedTransaction Transaction(LOCTEXT("CurveEditor_NewValue", "New Value Entered"));
		TSet<FRealCurve*> ChangedCurves;

		// Iterate over selected set
		for ( int32 i=0; i < SelectedKeys.Num(); i++ )
		{
			auto Key = SelectedKeys[i];
			if ( IsValidCurve(Key.Curve) )
			{
				CurveOwner->ModifyOwner();

				// Fill in each element of this key
				Key.Curve->SetKeyValue(Key.KeyHandle, NewValue);
				ChangedCurves.Add(Key.Curve);
			}
		}

		TArray<FRichCurveEditInfo> ChangedCurveEditInfos;
		for (auto CurveViewModel : CurveViewModels)
		{
			if (ChangedCurves.Contains(CurveViewModel->CurveInfo.CurveToEdit))
			{
				ChangedCurveEditInfos.Add(CurveViewModel->CurveInfo);
			}
		}
		CurveOwner->OnCurveChanged(ChangedCurveEditInfos);
	}
}

void SCurveEditor::OnBeginSliderMovement(FText TransactionName)
{
	bIsUsingSlider = true;

	GEditor->BeginTransaction(TransactionName);
}

void SCurveEditor::OnEndSliderMovement(float NewValue)
{
	bIsUsingSlider = false;

	GEditor->EndTransaction();
}

void SCurveEditor::OnEndSliderMovement(int32 NewValue)
{
	bIsUsingSlider = false;

	GEditor->EndTransaction();
}


SCurveEditor::FSelectedCurveKey SCurveEditor::HitTestKeys(const FGeometry& InMyGeometry, const FVector2D& HitScreenPosition)
{	
	FSelectedCurveKey SelectedKey(NULL,FKeyHandle());

	if( AreCurvesVisible() )
	{
		bool bAnyCurveViewModelsSelected = AnyCurveViewModelsSelected();

		FTrackScaleInfo ScaleInfo(ViewMinInput.Get(),  ViewMaxInput.Get(), ViewMinOutput.Get(), ViewMaxOutput.Get(), InMyGeometry.GetLocalSize());

		const FVector2D HitPosition = InMyGeometry.AbsoluteToLocal( HitScreenPosition );

		for(auto CurveViewModel : CurveViewModels)
		{
			if (IsCurveSelectable(CurveViewModel))
			{
				FRealCurve* Curve = CurveViewModel->CurveInfo.CurveToEdit;
				if(Curve != NULL)
				{
					for (auto It(Curve->GetKeyHandleIterator()); It; ++It)
					{
						float KeyScreenX = ScaleInfo.InputToLocalX(Curve->GetKeyTime(*It));
						float KeyScreenY = ScaleInfo.OutputToLocalY(Curve->GetKeyValue(*It));

						if(	HitPosition.X > (KeyScreenX - (0.5f * CONST_KeySize.X)) && 
							HitPosition.X < (KeyScreenX + (0.5f * CONST_KeySize.X)) &&
							HitPosition.Y > (KeyScreenY - (0.5f * CONST_KeySize.Y)) &&
							HitPosition.Y < (KeyScreenY + (0.5f * CONST_KeySize.Y)) )
						{
							return FSelectedCurveKey(Curve, *It);
						}
					}
				}
			}
		}
	}

	return SelectedKey;
}

void SCurveEditor::MoveSelectedKeys(FVector2D Delta)
{
	TArray<FRichCurveEditInfo> ChangedCurveEditInfos;

	const FScopedTransaction Transaction( LOCTEXT("CurveEditor_MoveKeys", "Move Keys") );
	CurveOwner->ModifyOwnerChange();

	// track all unique curves encountered so their tangents can be updated later
	TSet<FRealCurve*> UniqueCurves;

	// The total move distance for all keys is the difference between the current snapped location
	// and the start location of the key which was actually dragged.

	FVector2D TotalMoveDistance = Delta;

	for (int32 i = 0; i < SelectedKeys.Num(); i++)
	{
		FSelectedCurveKey OldKey = SelectedKeys[i];

		if (!IsValidCurve(OldKey.Curve))
		{
			continue;
		}

		FKeyHandle OldKeyHandle = OldKey.KeyHandle;
		FRealCurve* Curve = OldKey.Curve;

		FVector2D PreDragLocation = PreDragKeyLocations[OldKeyHandle];
		FVector2D NewLocation = PreDragLocation + TotalMoveDistance;

		// Update the key's value without updating the tangents.
		if (MovementAxisLock != EMovementAxisLock::AxisLock_Horizontal)
		{
			Curve->SetKeyValue(OldKeyHandle, NewLocation.Y, false);
		}

		// Changing the time of a key returns a new handle, so make sure to update existing references.
		if (MovementAxisLock != EMovementAxisLock::AxisLock_Vertical)
		{
			Curve->SetKeyTime(OldKeyHandle, NewLocation.X);
			SelectedKeys[i] = FSelectedCurveKey(Curve, OldKeyHandle);
			PreDragKeyLocations.Remove(OldKeyHandle);
			PreDragKeyLocations.Add(OldKeyHandle, PreDragLocation);
		}

		UniqueCurves.Add(Curve);
		ChangedCurveEditInfos.Add(GetViewModelForCurve(Curve)->CurveInfo);
	}

	if (CurveOwner->HasRichCurves())
	{
		// update auto tangents for all curves encountered, once each only
		for(TSet<FRealCurve*>::TIterator SetIt(UniqueCurves);SetIt;++SetIt)
		{
			((FRichCurve*)(*SetIt))->AutoSetTangents();
		}
	}

	if (ChangedCurveEditInfos.Num())
	{
		CurveOwner->OnCurveChanged(ChangedCurveEditInfos);
	}
}

TOptional<float> SCurveEditor::GetKeyValue(FSelectedCurveKey Key) const
{
	if(IsValidCurve(Key.Curve))
	{
		return Key.Curve->GetKeyValue(Key.KeyHandle);
	}

	return TOptional<float>();
}

TOptional<float> SCurveEditor::GetKeyTime(FSelectedCurveKey Key) const
{
	if ( IsValidCurve(Key.Curve) )
	{
		return Key.Curve->GetKeyTime(Key.KeyHandle);
	}

	return TOptional<float>();
}

void SCurveEditor::EmptyKeySelection()
{
	SelectedKeys.Empty();
}

void SCurveEditor::AddToKeySelection(FSelectedCurveKey Key)
{
	SelectedKeys.AddUnique(Key);
}

void SCurveEditor::RemoveFromKeySelection(FSelectedCurveKey Key)
{
	SelectedKeys.Remove(Key);
}

bool SCurveEditor::IsKeySelected(FSelectedCurveKey Key) const
{
	return SelectedKeys.Contains(Key);
}

bool SCurveEditor::AreKeysSelected() const
{
	return SelectedKeys.Num() > 0;
}

void SCurveEditor::EmptyTangentSelection()
{
	SelectedTangents.Empty();
}

void SCurveEditor::AddToTangentSelection(FSelectedTangent Tangent)
{
	SelectedTangents.Add(Tangent);
}

void SCurveEditor::RemoveFromTangentSelection(FSelectedTangent Tangent)
{
	SelectedTangents.Remove(Tangent);
}

bool SCurveEditor::IsTangentSelected(FSelectedTangent Tangent) const
{
	return SelectedTangents.Contains(Tangent);
}

bool SCurveEditor::AreTangentsSelected() const
{
	return SelectedTangents.Num() > 0;
}

bool SCurveEditor::IsTangentVisible(FRichCurve* Curve, FKeyHandle KeyHandle, bool& bIsTangentSelected, bool& bIsArrivalSelected, bool& bIsLeaveSelected) const
{
	bIsTangentSelected = false;
	bIsArrivalSelected = false;
	bIsLeaveSelected = false;

	bool IsSelected = IsKeySelected(FSelectedCurveKey(Curve,KeyHandle));
	for (auto SelectedTangent : SelectedTangents)
	{
		if (SelectedTangent.Key.KeyHandle == KeyHandle)
		{
			if (SelectedTangent.bIsArrival)
				bIsArrivalSelected = true;
			else
				bIsLeaveSelected = true;
			bIsTangentSelected = true;
		}
	}

	return (IsSelected || bIsTangentSelected || Settings->GetTangentVisibility() == ECurveEditorTangentVisibility::AllTangents) && Settings->GetTangentVisibility() != ECurveEditorTangentVisibility::NoTangents;
}

void SCurveEditor::EmptyAllSelection()
{
	EmptyKeySelection();
	EmptyTangentSelection();
}

void SCurveEditor::ValidateSelection()
{
	//remove all selection if we no longer have a curve interface (Curve Owner)
	if (!CurveOwner)
	{
		EmptyAllSelection();
		return;
	}

	//remove any invalid keys
	for(int32 i = 0;i<SelectedKeys.Num();++i)
	{
		auto Key = SelectedKeys[i];
		if(!IsValidCurve(Key.Curve) || !Key.IsValid())
		{
			SelectedKeys.RemoveAt(i);
			i--;
		}
	}

	// remove any invalid tangents
	for (int32 i = 0;i<SelectedTangents.Num();++i)
	{
		auto Tangent = SelectedTangents[i];
		if (!IsValidCurve(Tangent.Key.Curve) || !Tangent.Key.IsValid())
		{
			SelectedTangents.RemoveAt(i);
			i--;
		}
	}
}

bool SCurveEditor::GetAutoFrame() const
{
	return Settings->GetAutoFrameCurveEditor() && GetAllowAutoFrame();
}

TArray<FRealCurve*> SCurveEditor::GetCurvesToFit() const
{
	TArray<FRealCurve*> FitCurves;

	for(const TSharedPtr<FCurveViewModel>& CurveViewModel : CurveViewModels)
	{
		if (CurveViewModel->bIsVisible && CurveViewModel->CurveInfo.CurveToEdit != nullptr)
		{
			FitCurves.Add(CurveViewModel->CurveInfo.CurveToEdit);
		}
	}

	return FitCurves;
}


void SCurveEditor::ZoomToFitHorizontal(const bool bZoomToFitAll)
{
	TArray<FRealCurve*> CurvesToFit = GetCurvesToFit();

	if(CurveViewModels.Num() > 0)
	{
		float InMin = FLT_MAX;
		float InMax = -FLT_MAX;
		int32 TotalKeys = 0;

		if (SelectedKeys.Num() && !bZoomToFitAll)
		{
			for (auto SelectedKey : SelectedKeys)
			{
				TotalKeys++;
				float KeyTime = SelectedKey.Curve->GetKeyTime(SelectedKey.KeyHandle);
				InMin = FMath::Min(KeyTime, InMin);
				InMax = FMath::Max(KeyTime, InMax);

				FKeyHandle NextKeyHandle = SelectedKey.Curve->GetNextKey(SelectedKey.KeyHandle);
				if (SelectedKey.Curve->IsKeyHandleValid(NextKeyHandle))
				{
					float NextKeyTime = SelectedKey.Curve->GetKeyTime(NextKeyHandle);
					InMin = FMath::Min(NextKeyTime, InMin);
					InMax = FMath::Max(NextKeyTime, InMax);
				}

				FKeyHandle PreviousKeyHandle = SelectedKey.Curve->GetPreviousKey(SelectedKey.KeyHandle);
				if (SelectedKey.Curve->IsKeyHandleValid(PreviousKeyHandle))
				{
					float PreviousKeyTime = SelectedKey.Curve->GetKeyTime(PreviousKeyHandle);
					InMin = FMath::Min(PreviousKeyTime, InMin);
					InMax = FMath::Max(PreviousKeyTime, InMax);
				}
			}
		}
		else
		{
			for (FRealCurve* Curve : CurvesToFit)
			{
				float MinTime, MaxTime;
				Curve->GetTimeRange(MinTime, MaxTime);
				InMin = FMath::Min(MinTime, InMin);
				InMax = FMath::Max(MaxTime, InMax);
				TotalKeys += Curve->GetNumKeys();
			}
		}

		if (TotalKeys > 0)
		{
			// Clamp the minimum size
			float Size = InMax - InMin;
			if (Size < CONST_MinViewRange)
			{
				InMin -= (0.5f*CONST_MinViewRange);
				InMax += (0.5f*CONST_MinViewRange);
				Size = InMax - InMin;
			}

			// add margin
			InMin -= CONST_FitMargin*Size;
			InMax += CONST_FitMargin*Size;
		}
		else
		{
			InMin = -CONST_FitMargin*2.0f;
			InMax = (CONST_DefaultZoomRange + CONST_FitMargin)*2.0;
		}

		SetInputMinMax(InMin, InMax);
	}
}

FReply SCurveEditor::ZoomToFitHorizontalClicked()
{
	ZoomToFitHorizontal();
	return FReply::Handled();
}

/** Set Default output values when range is too small **/
void SCurveEditor::SetDefaultOutput(const float MinZoomRange)
{
	const float NewMinOutput = (ViewMinOutput.Get() - (0.5f*MinZoomRange));
	const float NewMaxOutput = (ViewMaxOutput.Get() + (0.5f*MinZoomRange));

	SetOutputMinMax(NewMinOutput, NewMaxOutput);
}

void SCurveEditor::ZoomToFitVertical(const bool bZoomToFitAll)
{
	TArray<FRealCurve*> CurvesToFit = GetCurvesToFit();

	if(CurvesToFit.Num() > 0)
	{
		float InMin = FLT_MAX;
		float InMax = -FLT_MAX;
		int32 TotalKeys = 0;

		if (SelectedKeys.Num() != 0 && !bZoomToFitAll)
		{
			for (auto SelectedKey : SelectedKeys)
			{
				TotalKeys++;
				float KeyValue = SelectedKey.Curve->GetKeyValue(SelectedKey.KeyHandle);
				InMin = FMath::Min(KeyValue, InMin);
				InMax = FMath::Max(KeyValue, InMax);

				FKeyHandle NextKeyHandle = SelectedKey.Curve->GetNextKey(SelectedKey.KeyHandle);
				if (SelectedKey.Curve->IsKeyHandleValid(NextKeyHandle))
				{
					float NextKeyValue = SelectedKey.Curve->GetKeyValue(NextKeyHandle);
					InMin = FMath::Min(NextKeyValue, InMin);
					InMax = FMath::Max(NextKeyValue, InMax);
				}

				FKeyHandle PreviousKeyHandle = SelectedKey.Curve->GetPreviousKey(SelectedKey.KeyHandle);
				if (SelectedKey.Curve->IsKeyHandleValid(PreviousKeyHandle))
				{
					float PreviousKeyValue = SelectedKey.Curve->GetKeyValue(PreviousKeyHandle);
					InMin = FMath::Min(PreviousKeyValue, InMin);
					InMax = FMath::Max(PreviousKeyValue, InMax);
				}
			}
		}
		else
		{
			for (FRealCurve* Curve : CurvesToFit)
			{
				float MinVal, MaxVal;
				Curve->GetValueRange(MinVal, MaxVal);
				InMin = FMath::Min(MinVal, InMin);
				InMax = FMath::Max(MaxVal, InMax);
				TotalKeys += Curve->GetNumKeys();
			}
		}

		const float MinZoomRange = (TotalKeys > 0 ) ? CONST_MinViewRange: CONST_DefaultZoomRange;

		// if in max and in min is same, then include 0.f
		if (InMax == InMin)
		{
			InMax = FMath::Max(InMax, 0.f);
			InMin = FMath::Min(InMin, 0.f);
		}

		// Clamp the minimum size
		float Size = InMax - InMin;
		if( Size < MinZoomRange )
		{
			SetDefaultOutput(MinZoomRange);
			InMin = ViewMinOutput.Get();
			InMax = ViewMaxOutput.Get();
			Size = InMax - InMin;
		}

		// add margin
		const float NewMinOutput = (InMin - CONST_FitMargin*Size);
		const float NewMaxOutput = (InMax + CONST_FitMargin*Size);

		SetOutputMinMax(NewMinOutput, NewMaxOutput);
	}
}

FReply SCurveEditor::ZoomToFitVerticalClicked()
{
	ZoomToFitVertical();
	return FReply::Handled();
}

void SCurveEditor::ZoomToFit(const bool bZoomToFitAll)
{
	ZoomToFitHorizontal(bZoomToFitAll);
	ZoomToFitVertical(bZoomToFitAll);
}

void SCurveEditor::ToggleInputSnapping()
{
	if (bInputSnappingEnabled.IsBound() == false)
	{
		bInputSnappingEnabled = !bInputSnappingEnabled.Get();
	}
}

void SCurveEditor::ToggleOutputSnapping()
{
	if (bOutputSnappingEnabled.IsBound() == false)
	{
		bOutputSnappingEnabled = !bOutputSnappingEnabled.Get();
	}
}

bool SCurveEditor::IsInputSnappingEnabled() const
{
	return bInputSnappingEnabled.Get();
}

bool SCurveEditor::IsOutputSnappingEnabled() const
{
	return bOutputSnappingEnabled.Get();
}

bool SCurveEditor::ShowTimeInFrames() const
{
	return bShowTimeInFrames.Get();
}

void SCurveEditor::CreateContextMenu(const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent)
{
	TSharedPtr<TArray<TSharedPtr<FCurveViewModel>>> CurvesToAddKeysTo = MakeShareable(new TArray<TSharedPtr<FCurveViewModel>>());

	bool bHoveredCurveValid = false;
	TSharedPtr<FCurveViewModel> HoveredCurve = HitTestCurves(InMyGeometry, InMouseEvent);
	//Curve must be visible and unlocked to show context menu
	if (HoveredCurve.IsValid() && !HoveredCurve->bIsLocked && HoveredCurve->bIsVisible)
	{
		CurvesToAddKeysTo->Add(HoveredCurve);
		bHoveredCurveValid = true;
	}
	else
	{
		// Get all editable curves
		for (auto CurveViewModel : CurveViewModels)
		{
			if (!CurveViewModel->bIsLocked)
			{
				CurvesToAddKeysTo->Add(CurveViewModel);
			}
		}
	}

	const bool bCreateExternalCurve = OnCreateAsset.IsBound() && IsEditingEnabled();
	const bool bShowLinearColorCurve = IsLinearColorCurve();

	// Early out if there's no menu items to show
	if (CurvesToAddKeysTo->Num() == 0 && !bCreateExternalCurve && !bShowLinearColorCurve)
	{
		return;
	}	

	const FVector2D& ScreenPosition = InMouseEvent.GetScreenSpacePosition();

	const bool CloseAfterSelection = true;
	FMenuBuilder MenuBuilder( CloseAfterSelection, NULL );

	MenuBuilder.BeginSection("EditCurveEditorActions", LOCTEXT("Actions", "Actions"));
	{
		FText MenuItemLabel;
		FText MenuItemToolTip;

		FText AddKeyToCurveLabelFormat = LOCTEXT("AddKeyToCurveLabelFormat", "Add key to {0}");
		FText AddKeyToCurveToolTipFormat = LOCTEXT("AddKeyToCurveToolTipFormat", "Add a new key at the hovered time to the {0} curve.  Keys can also be added with Shift + Click.");

		FVector2D Position = InMouseEvent.GetScreenSpacePosition();
	
		if (bHoveredCurveValid)
		{
			MenuItemLabel = FText::Format(AddKeyToCurveLabelFormat, FText::FromName(HoveredCurve->CurveInfo.CurveName));
			MenuItemToolTip = FText::Format(AddKeyToCurveToolTipFormat, FText::FromName(HoveredCurve->CurveInfo.CurveName));
			FUIAction Action = FUIAction(FExecuteAction::CreateSP(this, &SCurveEditor::AddNewKey, InMyGeometry, Position, CurvesToAddKeysTo, true));
			MenuBuilder.AddMenuEntry(MenuItemLabel, MenuItemToolTip, FSlateIcon(), Action);
		}
		else
		{
			if (CurvesToAddKeysTo->Num() == 1)
			{
				MenuItemLabel = FText::Format(AddKeyToCurveLabelFormat, FText::FromName((*CurvesToAddKeysTo)[0]->CurveInfo.CurveName));
				MenuItemToolTip = FText::Format(AddKeyToCurveToolTipFormat, FText::FromName((*CurvesToAddKeysTo)[0]->CurveInfo.CurveName));
				FUIAction Action = FUIAction(FExecuteAction::CreateSP(this, &SCurveEditor::AddNewKey, InMyGeometry, Position, CurvesToAddKeysTo, false));
				MenuBuilder.AddMenuEntry(MenuItemLabel, MenuItemToolTip, FSlateIcon(), Action);
			}
			else if (CurvesToAddKeysTo->Num() > 1) //Dont show the menu if we cannot edit any curve
			{
				//add key to all curve menu entry
				MenuItemLabel = LOCTEXT("AddKeyToAllCurves", "Add key to all curves");
				MenuItemToolTip = LOCTEXT("AddKeyToAllCurveToolTip", "Adds a key at the hovered time to all curves.  Keys can also be added with Shift + Click.");
				FUIAction Action = FUIAction(FExecuteAction::CreateSP(this, &SCurveEditor::AddNewKey, InMyGeometry, Position, CurvesToAddKeysTo, true));
				MenuBuilder.AddMenuEntry(MenuItemLabel, MenuItemToolTip, FSlateIcon(), Action);
				
				//This menu is not required when there is no curve display (color track can hide and show curves)
				if (bAreCurvesVisible.Get())
				{
					//add key and value to all curve menu entry
					MenuItemLabel = LOCTEXT("AddKeyValueToAllCurves", "Add key & value to all curves");
					MenuItemToolTip = LOCTEXT("AddKeyValueToAllCurveToolTip", "Adds a key & value at the hovered time to all curves.  Keys can also be added with Shift + ctrl + Click.");
					Action = FUIAction(FExecuteAction::CreateSP(this, &SCurveEditor::AddNewKey, InMyGeometry, Position, CurvesToAddKeysTo, false));
					MenuBuilder.AddMenuEntry(MenuItemLabel, MenuItemToolTip, FSlateIcon(), Action);
				}
			}
		}
	}
	MenuBuilder.EndSection();

	MenuBuilder.BeginSection("CurveEditorActions", LOCTEXT("CurveAction", "Curve Actions") );
	{
		if( bCreateExternalCurve )
		{
			FUIAction Action = FUIAction( FExecuteAction::CreateSP( this, &SCurveEditor::OnCreateExternalCurveClicked ) );
			MenuBuilder.AddMenuEntry
			( 
				LOCTEXT("CreateExternalCurve", "Create External Curve"),
				LOCTEXT("CreateExternalCurve_ToolTip", "Create an external asset using this internal curve"), 
				FSlateIcon(), 
				Action
			);
		}

		if( IsLinearColorCurve() && !bAlwaysDisplayColorCurves )
		{
			FUIAction ShowCurveAction( FExecuteAction::CreateSP( this, &SCurveEditor::OnShowCurveToggled ), FCanExecuteAction(), FIsActionChecked::CreateSP( this, &SCurveEditor::AreCurvesVisible ) );
			MenuBuilder.AddMenuEntry
			(
				LOCTEXT("ShowCurves","Show Curves"),
				LOCTEXT("ShowCurves_ToolTip", "Toggles displaying the curves for linear colors"),
				FSlateIcon(),
				ShowCurveAction,
				NAME_None,
				EUserInterfaceActionType::ToggleButton 
			);
		}

		if( IsLinearColorCurve() && !bAlwaysHideGradientEditor)
		{
			FUIAction ShowGradientAction( FExecuteAction::CreateSP( this, &SCurveEditor::OnShowGradientToggled ), FCanExecuteAction(), FIsActionChecked::CreateSP( this, &SCurveEditor::IsGradientEditorVisible ) );
			MenuBuilder.AddMenuEntry
			(
				LOCTEXT("ShowGradient","Show Gradient"),
				LOCTEXT("ShowGradient_ToolTip", "Toggles displaying the gradient for linear colors"),
				FSlateIcon(),
				ShowGradientAction,
				NAME_None,
				EUserInterfaceActionType::ToggleButton 
			);
		}
	}

	MenuBuilder.EndSection();

	FWidgetPath WidgetPath = InMouseEvent.GetEventPath() != nullptr ? *InMouseEvent.GetEventPath() : FWidgetPath();
	FSlateApplication::Get().PushMenu(SharedThis(this), WidgetPath, MenuBuilder.MakeWidget(), FSlateApplication::Get().GetCursorPos(), FPopupTransitionEffect(FPopupTransitionEffect::ContextMenu));
}

void SCurveEditor::OnCreateExternalCurveClicked()
{
	OnCreateAsset.ExecuteIfBound();
}

void SCurveEditor::OnShowCurveToggled()
{
	if (bAreCurvesVisible.IsBound() && SetAreCurvesVisibleHandler.IsBound())
	{
		SetAreCurvesVisibleHandler.Execute(!bAreCurvesVisible.Get());
	}
	else
	{
		bAreCurvesVisible = !bAreCurvesVisible.Get();
	}
}

UObject* SCurveEditor::CreateCurveObject( TSubclassOf<UCurveBase> CurveType, UObject* PackagePtr, FName& AssetName )
{
	UObject* NewObj = NULL;
	CurveFactory = Cast<UCurveFactory>(NewObject<UFactory>(GetTransientPackage(), UCurveFactory::StaticClass()));
	if(CurveFactory)
	{
		CurveFactory->CurveClass = CurveType;
		NewObj = CurveFactory->FactoryCreateNew( CurveFactory->GetSupportedClass(), PackagePtr, AssetName, RF_Public|RF_Standalone, NULL, GWarn );
	}
	CurveFactory = NULL;
	return NewObj;
}

bool SCurveEditor::IsEditingEnabled() const
{
	return bCanEditTrack;
}

void SCurveEditor::AddReferencedObjects( FReferenceCollector& Collector )
{
	Collector.AddReferencedObject( Settings );
	Collector.AddReferencedObject( CurveFactory );
}

TSharedPtr<FUICommandList> SCurveEditor::GetCommands()
{
	return Commands;
}

bool SCurveEditor::IsValidCurve( FRealCurve* Curve ) const
{
	bool bIsValid = false;
	if(Curve && CurveOwner)
	{
		for(auto CurveViewModel : CurveViewModels)
		{
			if(CurveViewModel->CurveInfo.CurveToEdit == Curve && CurveOwner->IsValidCurve(CurveViewModel->CurveInfo))
			{
				bIsValid = true;
				break;
			}
		}
	}
	return bIsValid;
}

void SCurveEditor::SetInputMinMax(float NewMin, float NewMax)
{
	if (SetInputViewRangeHandler.IsBound())
	{
		SetInputViewRangeHandler.Execute(NewMin, NewMax);
	}
	else
	{
		//if no delegate and view min input isn't using a delegate just set value directly
		if (ViewMinInput.IsBound() == false)
		{
			ViewMinInput.Set(NewMin);
		}

		if (ViewMaxInput.IsBound() == false)
		{
			ViewMaxInput.Set(NewMax);
		}
	}
}

void SCurveEditor::SetOutputMinMax(float NewMin, float NewMax)
{
	if (SetOutputViewRangeHandler.IsBound())
	{
		SetOutputViewRangeHandler.Execute(NewMin, NewMax);
	}
	else
	{
		//if no delegate and view min output isn't using a delegate just set value directly
		if (ViewMinOutput.IsBound() == false)
		{
			ViewMinOutput.Set(NewMin);
		}

		if (ViewMaxOutput.IsBound() == false)
		{
			ViewMaxOutput.Set(NewMax);
		}
	}
}

void SCurveEditor::EmptyAllCurveViewModels()
{
	CurveViewModels.Empty();
}

void SCurveEditor::ClearSelectedCurveViewModels()
{
	for(auto CurveViewModel : CurveViewModels)
	{
		CurveViewModel->bIsSelected = false;
	}
}

void SCurveEditor::SetSelectedCurveViewModel(FRealCurve* CurveToSelect)
{
	TSharedPtr<FCurveViewModel> ViewModel = GetViewModelForCurve(CurveToSelect);
	if (ViewModel.IsValid())
	{
		ViewModel.Get()->bIsSelected = true;
	}
}

bool SCurveEditor::AnyCurveViewModelsSelected() const
{
	for (auto CurveViewModel : CurveViewModels)
	{
		if (CurveViewModel->bIsSelected)
		{
			return true;
		}
	}
	return false;
}

TSharedPtr<FCurveViewModel> SCurveEditor::HitTestCurves(  const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent )
{
	if( AreCurvesVisible() )
	{
		FTrackScaleInfo ScaleInfo(ViewMinInput.Get(),  ViewMaxInput.Get(), ViewMinOutput.Get(), ViewMaxOutput.Get(), InMyGeometry.GetLocalSize());

		const FVector2D HitPosition = InMyGeometry.AbsoluteToLocal( InMouseEvent.GetScreenSpacePosition()  );

		TArray<FRealCurve*> CurvesHit;

		for(auto CurveViewModel : CurveViewModels)
		{

			FRealCurve* Curve = CurveViewModel->CurveInfo.CurveToEdit;

			if (IsValidCurve(Curve))
			{
				float Time		 = ScaleInfo.LocalXToInput(HitPosition.X);
				float KeyScreenY = ScaleInfo.OutputToLocalY(Curve->Eval(Time));

				if( HitPosition.Y > (KeyScreenY - (0.5f * CONST_CurveSize.Y)) &&
					HitPosition.Y < (KeyScreenY + (0.5f * CONST_CurveSize.Y)))
				{
					return CurveViewModel;
				}
			}
		}
	}

	return TSharedPtr<FCurveViewModel>();
}

bool SCurveEditor::IsCurveSelectable(TSharedPtr<FCurveViewModel> CurveViewModel) const
{		
	bool bAnyCurveViewModelsSelected = AnyCurveViewModelsSelected();
	bool bDisabled = bAnyCurveViewModelsSelected && !CurveViewModel->bIsSelected;

	return !CurveViewModel->bIsLocked && CurveViewModel->bIsVisible && !bDisabled;
}

SCurveEditor::FSelectedTangent SCurveEditor::HitTestCubicTangents( const FGeometry& InMyGeometry, const FVector2D& HitScreenPosition )
{
	FSelectedTangent Tangent;

	if( AreCurvesVisible() && CurveOwner && CurveOwner->HasRichCurves() )
	{
		FTrackScaleInfo ScaleInfo(ViewMinInput.Get(),  ViewMaxInput.Get(), ViewMinOutput.Get(), ViewMaxOutput.Get(), InMyGeometry.GetLocalSize());

		const FVector2D HitPosition = InMyGeometry.AbsoluteToLocal( HitScreenPosition);

		for (auto CurveViewModel : CurveViewModels)
		{
			if (IsCurveSelectable(CurveViewModel))
			{
				FRichCurve* Curve = (FRichCurve*)CurveViewModel->CurveInfo.CurveToEdit;
				if (Curve != NULL)
				{
					for (auto It(Curve->GetKeyHandleIterator()); It; ++It)
					{
						FKeyHandle KeyHandle = *It;
						FSelectedCurveKey SelectedCurveKey(Curve, KeyHandle);

						if(SelectedCurveKey.IsValid())
						{
							bool bIsTangentSelected = false;
							bool bIsArrivalSelected = false;
							bool bIsLeaveSelected = false;
							bool bIsTangentVisible = IsTangentVisible(Curve, KeyHandle, bIsTangentSelected, bIsArrivalSelected, bIsLeaveSelected);

							if (bIsTangentVisible)
							{
								float Time		 = ScaleInfo.LocalXToInput(HitPosition.X);
								float KeyScreenY = ScaleInfo.OutputToLocalY(Curve->Eval(Time));

								FVector2D Arrive, Leave;
								GetTangentPoints(ScaleInfo, SelectedCurveKey, Arrive, Leave);

								if( HitPosition.Y > (Arrive.Y - (0.5f * CONST_CurveSize.Y)) &&
									HitPosition.Y < (Arrive.Y + (0.5f * CONST_CurveSize.Y)) &&
									HitPosition.X > (Arrive.X - (0.5f * CONST_TangentSize.X)) && 
									HitPosition.X < (Arrive.X + (0.5f * CONST_TangentSize.X)))
								{
									Tangent.Key = SelectedCurveKey;
									Tangent.bIsArrival = true;
									break;
								}
								if( HitPosition.Y > (Leave.Y - (0.5f * CONST_CurveSize.Y)) &&
									HitPosition.Y < (Leave.Y  + (0.5f * CONST_CurveSize.Y)) &&
									HitPosition.X > (Leave.X - (0.5f * CONST_TangentSize.X)) && 
									HitPosition.X < (Leave.X + (0.5f * CONST_TangentSize.X)))
								{
									Tangent.Key = SelectedCurveKey;
									Tangent.bIsArrival = false;
									break;
								}
							}
						}
					}
				}
			}
		}
	}

	return Tangent;
}

void SCurveEditor::OnSelectInterpolationMode(ERichCurveInterpMode InterpMode, ERichCurveTangentMode TangentMode)
{
	const bool bHasRichCurves = CurveOwner->HasRichCurves();
	if((SelectedKeys.Num() > 0 || SelectedTangents.Num() > 0) && (InterpMode != RCIM_Cubic || bHasRichCurves))
	{
		const FScopedTransaction Transaction(LOCTEXT("CurveEditor_SetInterpolationMode", "Select Interpolation Mode"));
		CurveOwner->ModifyOwner();

		if (bHasRichCurves)
		{
			for (auto It = SelectedKeys.CreateIterator(); It; ++It)
			{
				FSelectedCurveKey& Key = *It;
				FRichCurve* RichCurve = (FRichCurve*)Key.Curve;
				check(IsValidCurve(RichCurve));
				RichCurve->SetKeyInterpMode(Key.KeyHandle, InterpMode);
				RichCurve->SetKeyTangentMode(Key.KeyHandle, TangentMode);
			}

			for (auto It = SelectedTangents.CreateIterator(); It; ++It)
			{
				FSelectedTangent& Tangent = *It;
				FRichCurve* RichCurve = (FRichCurve*)Tangent.Key.Curve;
				check(IsValidCurve(RichCurve));
				RichCurve->SetKeyInterpMode(Tangent.Key.KeyHandle, InterpMode);
				RichCurve->SetKeyTangentMode(Tangent.Key.KeyHandle, TangentMode);
			}
		}
		else
		{
			for (auto It = SelectedKeys.CreateIterator(); It; ++It)
			{
				FSelectedCurveKey& Key = *It;
				FSimpleCurve* SimpleCurve = (FSimpleCurve*)Key.Curve;
				check(IsValidCurve(SimpleCurve));
				SimpleCurve->SetKeyInterpMode(InterpMode);
			}
		}

		TArray<FRichCurveEditInfo> ChangedCurveEditInfos;
		CurveOwner->OnCurveChanged(ChangedCurveEditInfos);
	}
}

bool SCurveEditor::IsInterpolationModeSelected(ERichCurveInterpMode InterpMode, ERichCurveTangentMode TangentMode)
{
	const bool bHasRichCurves = CurveOwner->HasRichCurves();
	if (SelectedKeys.Num() > 0)
	{
		for (auto SelectedKey : SelectedKeys)
		{
			if (SelectedKey.Curve->GetKeyInterpMode(SelectedKey.KeyHandle) != InterpMode || (bHasRichCurves && ((FRichCurve*)SelectedKey.Curve)->GetKeyTangentMode(SelectedKey.KeyHandle) != TangentMode))
			{
				return false;
			}
		}
		return true;
	}
	else if (SelectedTangents.Num() > 0)
	{
		for (auto SelectedTangent : SelectedTangents)
		{
			if (SelectedTangent.Key.Curve->GetKeyInterpMode(SelectedTangent.Key.KeyHandle) != InterpMode || ((FRichCurve*)SelectedTangent.Key.Curve)->GetKeyTangentMode(SelectedTangent.Key.KeyHandle) != TangentMode)
			{
				return false;
			}
		}
		return true;
	}
	else
	{
		return false;
	}
}

bool SCurveEditor::HasRichCurves() const
{
	return CurveOwner->HasRichCurves();
}

void SCurveEditor::OnFlattenOrStraightenTangents(bool bFlattenTangents)
{
	if ((SelectedKeys.Num() > 0 || SelectedTangents.Num() > 0) && CurveOwner->HasRichCurves())
	{
		const FScopedTransaction Transaction(LOCTEXT("CurveEditor_FlattenTangents", "Flatten Tangents"));
		CurveOwner->ModifyOwner();

		auto OnFlattenOrStraightenTangents_Internal = [this, bFlattenTangents](FSelectedCurveKey& Key)
		{
			FRichCurve* RichCurve = (FRichCurve*)Key.Curve;
			check(IsValidCurve(RichCurve));

			float LeaveTangent = RichCurve->GetKey(Key.KeyHandle).LeaveTangent;
			float ArriveTangent = RichCurve->GetKey(Key.KeyHandle).ArriveTangent;

			if (bFlattenTangents)
			{
				LeaveTangent = 0;
				ArriveTangent = 0;
			}
			else
			{
				LeaveTangent = (LeaveTangent + ArriveTangent) * 0.5f;
				ArriveTangent = LeaveTangent;
			}

			RichCurve->GetKey(Key.KeyHandle).LeaveTangent = LeaveTangent;
			RichCurve->GetKey(Key.KeyHandle).ArriveTangent = ArriveTangent;
			if (RichCurve->GetKey(Key.KeyHandle).InterpMode == RCIM_Cubic &&
				RichCurve->GetKey(Key.KeyHandle).TangentMode == RCTM_Auto)
			{
				RichCurve->GetKey(Key.KeyHandle).TangentMode = RCTM_User;
			}
		};

		for(auto It = SelectedKeys.CreateIterator();It;++It)
		{
			OnFlattenOrStraightenTangents_Internal(*It);
		}
				
		for(auto It = SelectedTangents.CreateIterator();It;++It)
		{
			OnFlattenOrStraightenTangents_Internal(It->Key);
		}

		TArray<FRichCurveEditInfo> ChangedCurveEditInfos;
		CurveOwner->OnCurveChanged(ChangedCurveEditInfos);
	}
}

void SCurveEditor::OnBakeCurve()
{
	float BakeSampleRate = InputSnap.IsSet() ? InputSnap.Get() : 0.05f;

	// Display dialog and let user enter sample rate.
	GenericTextEntryModeless(
		NSLOCTEXT("CurveEditor.Popups", "BakeSampleRate", "Sample Rate"),
		FText::AsNumber( BakeSampleRate ),
		FOnTextCommitted::CreateSP(this, &SCurveEditor::OnBakeCurveSampleRateCommitted)
		);
}

void SCurveEditor::OnBakeCurveSampleRateCommitted(const FText& InText, ETextCommit::Type CommitInfo)
{
	CloseEntryPopupMenu();
	if (CommitInfo == ETextCommit::OnEnter)
	{
		double NewBakeSampleRate = FCString::Atod(*InText.ToString());
		const bool bIsNumber = InText.IsNumeric(); 
		if (!bIsNumber)
		{
			return;
		}
		if (NewBakeSampleRate <= 0.0)
		{
			UE_LOG(LogCurveEditor, Error, TEXT("Invalid Bake Sample Rate"));
			return;
		}

		const float BakeSampleRate = (float)NewBakeSampleRate;

		const FScopedTransaction Transaction(LOCTEXT("CurveEditor_BakeCurve", "Bake Curve"));
		CurveOwner->ModifyOwner();

		bool bAnyCurveViewModelsSelected = AnyCurveViewModelsSelected();

		TArray<FRichCurveEditInfo> ChangedCurveEditInfos;

		// If keys are selected, bake between them
		TMap<FRealCurve*, TInterval<float> > CurveRangeMap;
		for (auto SelectedKey : SelectedKeys)
		{
			float SelectedTime = SelectedKey.Curve->GetKeyTime(SelectedKey.KeyHandle);
			if (CurveRangeMap.Find(SelectedKey.Curve) != nullptr)
			{
				CurveRangeMap[SelectedKey.Curve].Include(SelectedTime);
			}
			else
			{
				CurveRangeMap.Add(SelectedKey.Curve, TInterval<float>(SelectedTime, SelectedTime));
			}
		}

		if (CurveRangeMap.Num())
		{
			for (auto CurveToBake : CurveRangeMap)
			{
				if (CurveToBake.Value.Min != CurveToBake.Value.Max)
				{
					CurveToBake.Key->BakeCurve(BakeSampleRate, CurveToBake.Value.Min, CurveToBake.Value.Max);
					ChangedCurveEditInfos.Add(GetViewModelForCurve(CurveToBake.Key)->CurveInfo);
				}
				else
				{
					UE_LOG(LogCurveEditor, Warning, TEXT("Unable to bake single-point curve. Check if you don't have a single key selected before Baking."));
				}
			}
		}
		else
		{
			for (auto CurveViewModel : CurveViewModels)
			{
				if (!bAnyCurveViewModelsSelected || CurveViewModel->bIsSelected)
				{
					CurveViewModel->CurveInfo.CurveToEdit->BakeCurve(BakeSampleRate);
					ChangedCurveEditInfos.Add(CurveViewModel->CurveInfo);
				}
			}
		}

		if (ChangedCurveEditInfos.Num())
		{
			CurveOwner->OnCurveChanged(ChangedCurveEditInfos);
		}
	}
}

void SCurveEditor::OnReduceCurve()
{
	// Display dialog and let user enter tolerance.
	GenericTextEntryModeless(
		NSLOCTEXT("CurveEditor.Popups", "ReduceCurveTolerance", "Tolerance"),
		FText::AsNumber( ReduceTolerance ),
		FOnTextCommitted::CreateSP(this, &SCurveEditor::OnReduceCurveToleranceCommitted)
		);
}

void SCurveEditor::OnReduceCurveToleranceCommitted(const FText& InText, ETextCommit::Type CommitInfo)
{
	CloseEntryPopupMenu();
	if (CommitInfo == ETextCommit::OnEnter)
	{
		double NewTolerance = FCString::Atod(*InText.ToString());
		const bool bIsNumber = InText.IsNumeric(); 
		if(!bIsNumber)
			return;

		ReduceTolerance = (float)NewTolerance;

		const FScopedTransaction Transaction(LOCTEXT("CurveEditor_ReduceCurve", "Reduce Curve"));
		CurveOwner->ModifyOwner();

		bool bAnyCurveViewModelsSelected = AnyCurveViewModelsSelected();

		TArray<FRichCurveEditInfo> ChangedCurveEditInfos;

		// If keys are selected, bake between them
		TMap<FRealCurve*, TInterval<float> > CurveRangeMap;
		for (auto SelectedKey : SelectedKeys)
		{
			float SelectedTime = SelectedKey.Curve->GetKeyTime(SelectedKey.KeyHandle);
			if (CurveRangeMap.Find(SelectedKey.Curve) != nullptr)
			{
				CurveRangeMap[SelectedKey.Curve].Include(SelectedTime);
			}
			else
			{
				CurveRangeMap.Add(SelectedKey.Curve, TInterval<float>(SelectedTime, SelectedTime));
			}
		}

		if (CurveRangeMap.Num())
		{
			for (auto CurveToBake : CurveRangeMap)
			{
				CurveToBake.Key->RemoveRedundantKeys(ReduceTolerance, CurveToBake.Value.Min, CurveToBake.Value.Max);
				ChangedCurveEditInfos.Add(GetViewModelForCurve(CurveToBake.Key)->CurveInfo);
			}
		}
		else
		{
			for (auto CurveViewModel : CurveViewModels)
			{
				if (!bAnyCurveViewModelsSelected || CurveViewModel->bIsSelected)
				{
					CurveViewModel->CurveInfo.CurveToEdit->RemoveRedundantKeys(ReduceTolerance);
					ChangedCurveEditInfos.Add(CurveViewModel->CurveInfo);
				}
			}
		}

		if (ChangedCurveEditInfos.Num())
		{
			CurveOwner->OnCurveChanged(ChangedCurveEditInfos);
		}
	}
}


void SCurveEditor::OnSelectPreInfinityExtrap(ERichCurveExtrapolation Extrapolation)
{
	const FScopedTransaction Transaction(LOCTEXT("CurveEditor_SetPreInfinityExtrapolation", "Set Pre-Infinity Extrapolation"));
	CurveOwner->ModifyOwner();

	bool bAnyCurveViewModelsSelected = AnyCurveViewModelsSelected();

	TArray<FRichCurveEditInfo> ChangedCurveEditInfos;
	for (auto CurveViewModel : CurveViewModels)
	{
		if (!bAnyCurveViewModelsSelected || CurveViewModel->bIsSelected)
		{
			if (CurveViewModel->CurveInfo.CurveToEdit->PreInfinityExtrap != Extrapolation)
			{
				CurveViewModel->CurveInfo.CurveToEdit->PreInfinityExtrap = Extrapolation;
				ChangedCurveEditInfos.Add(CurveViewModel->CurveInfo);
			}
		}
	}

	if (ChangedCurveEditInfos.Num())
	{
		CurveOwner->OnCurveChanged(ChangedCurveEditInfos);
	}
}

bool SCurveEditor::IsPreInfinityExtrapSelected(ERichCurveExtrapolation Extrapolation)
{
	bool bAnyCurveViewModelsSelected = AnyCurveViewModelsSelected();

	for (auto CurveViewModel : CurveViewModels)
	{
		// If there are any curves selected, the setting must match all of the selected curves
		if (bAnyCurveViewModelsSelected)
		{
			if (CurveViewModel->bIsSelected)
			{
				if (CurveViewModel->CurveInfo.CurveToEdit->PreInfinityExtrap != Extrapolation)
				{
					return false;
				}
			}
		}
		else
		{
			if (CurveViewModel->CurveInfo.CurveToEdit->PreInfinityExtrap != Extrapolation)
			{
				return false;
			}
		}
	}

	return CurveViewModels.Num() > 0;
}

void SCurveEditor::OnSelectPostInfinityExtrap(ERichCurveExtrapolation Extrapolation)
{
	const FScopedTransaction Transaction(LOCTEXT("CurveEditor_SetPostInfinityExtrapolation", "Set Post-Infinity Extrapolation"));
	CurveOwner->ModifyOwner();

	bool bAnyCurveViewModelsSelected = AnyCurveViewModelsSelected();

	TArray<FRichCurveEditInfo> ChangedCurveEditInfos;
	for (auto CurveViewModel : CurveViewModels)
	{
		if (!bAnyCurveViewModelsSelected || CurveViewModel->bIsSelected)
		{
			if (CurveViewModel->CurveInfo.CurveToEdit->PostInfinityExtrap != Extrapolation)
			{
				CurveViewModel->CurveInfo.CurveToEdit->PostInfinityExtrap = Extrapolation;
				ChangedCurveEditInfos.Add(CurveViewModel->CurveInfo);
			}
		}
	}

	if (ChangedCurveEditInfos.Num())
	{
		CurveOwner->OnCurveChanged(ChangedCurveEditInfos);
	}
}

bool SCurveEditor::IsPostInfinityExtrapSelected(ERichCurveExtrapolation Extrapolation)
{
	bool bAnyCurveViewModelsSelected = AnyCurveViewModelsSelected();

	for (auto CurveViewModel : CurveViewModels)
	{
		// If there are any curves selected, the setting must match all of the selected curves
		if (bAnyCurveViewModelsSelected)
		{
			if (CurveViewModel->bIsSelected)
			{
				if (CurveViewModel->CurveInfo.CurveToEdit->PostInfinityExtrap != Extrapolation)
				{
					return false;
				}
			}
		}
		else
		{
			if (CurveViewModel->CurveInfo.CurveToEdit->PostInfinityExtrap != Extrapolation)
			{
				return false;
			}
		}
	}

	return CurveViewModels.Num() > 0;
}

void SCurveEditor::MoveTangents(FTrackScaleInfo& ScaleInfo, FVector2D Delta)
{
	TArray<FRichCurveEditInfo> ChangedCurveEditInfos;
	CurveOwner->ModifyOwnerChange();

	for (const FSelectedTangent& SelectedTangent : SelectedTangents)
	{
		FRichCurveKey& RichKey = ((FRichCurve*)SelectedTangent.Key.Curve)->GetKey(SelectedTangent.Key.KeyHandle);

		const FSelectedCurveKey &Key = SelectedTangent.Key;
		float PreDragArriveTangent = PreDragTangents[SelectedTangent.Key.KeyHandle][0];
		float PreDragLeaveTangent = PreDragTangents[SelectedTangent.Key.KeyHandle][1];

		// Get tangent points in screen space
		FVector2D ArriveTangentDir = CalcTangentDir( PreDragArriveTangent );
		FVector2D LeaveTangentDir = CalcTangentDir( PreDragLeaveTangent );

		FVector2D KeyPosition( Key.Curve->GetKeyTime(Key.KeyHandle),Key.Curve->GetKeyValue(Key.KeyHandle) );

		ArriveTangentDir.Y *= -1.0f;
		LeaveTangentDir.Y *= -1.0f;
		FVector2D ArrivePosition = -ArriveTangentDir + KeyPosition;

		FVector2D LeavePosition = LeaveTangentDir + KeyPosition;

		FVector2D Arrive = FVector2D(ScaleInfo.InputToLocalX(ArrivePosition.X), ScaleInfo.OutputToLocalY(ArrivePosition.Y));
		FVector2D Leave = FVector2D(ScaleInfo.InputToLocalX(LeavePosition.X), ScaleInfo.OutputToLocalY(LeavePosition.Y));

		FVector2D KeyScreenPosition = FVector2D(ScaleInfo.InputToLocalX(KeyPosition.X), ScaleInfo.OutputToLocalY(KeyPosition.Y));

		FVector2D ToArrive = Arrive - KeyScreenPosition;
		ToArrive.Normalize();

		Arrive = KeyScreenPosition + ToArrive*CONST_KeyTangentOffset;

		FVector2D ToLeave = Leave - KeyScreenPosition;
		ToLeave.Normalize();

		Leave = KeyScreenPosition + ToLeave*CONST_KeyTangentOffset;

		// New arrive and leave directions in screen space
		if (SelectedTangent.bIsArrival)
		{
			Arrive += Delta;
			Leave -= Delta;
		}
		else
		{
			Arrive -= Delta;
			Leave += Delta;
		}

		// Convert back to input/output space
		FVector2D NewArriveDir(ScaleInfo.LocalXToInput(Arrive.X), ScaleInfo.LocalYToOutput(Arrive.Y));
		FVector2D NewLeaveDir(ScaleInfo.LocalXToInput(Leave.X), ScaleInfo.LocalYToOutput(Leave.Y));

		// Compute tangents
		float NewArriveTangent = CalcTangent(-1.f*(NewArriveDir - KeyPosition));
		float NewLeaveTangent = CalcTangent(NewLeaveDir - KeyPosition);

		if(RichKey.TangentMode != RCTM_Break)
		{
			RichKey.ArriveTangent = NewArriveTangent;
			RichKey.LeaveTangent = NewLeaveTangent;
		
			RichKey.TangentMode = RCTM_User;
		}
		else
		{
			if(SelectedTangent.bIsArrival)
			{
				RichKey.ArriveTangent = NewArriveTangent;
			}
			else
			{
				RichKey.LeaveTangent = NewLeaveTangent;
			}
		}	

		RichKey.InterpMode = RCIM_Cubic;

		ChangedCurveEditInfos.Add(GetViewModelForCurve(SelectedTangent.Key.Curve)->CurveInfo);
	}

	if (ChangedCurveEditInfos.Num())
	{
		CurveOwner->OnCurveChanged(ChangedCurveEditInfos);
	}
}

void SCurveEditor::GetTangentPoints(  FTrackScaleInfo &ScaleInfo, const FSelectedCurveKey &Key, FVector2D& Arrive, FVector2D& Leave ) const
{
	FVector2D ArriveTangentDir = CalcTangentDir( ((FRichCurve*)Key.Curve)->GetKey(Key.KeyHandle).ArriveTangent);
	FVector2D LeaveTangentDir = CalcTangentDir( ((FRichCurve*)Key.Curve)->GetKey(Key.KeyHandle).LeaveTangent);

	FVector2D KeyPosition( Key.Curve->GetKeyTime(Key.KeyHandle),Key.Curve->GetKeyValue(Key.KeyHandle) );

	ArriveTangentDir.Y *= -1.0f;
	LeaveTangentDir.Y *= -1.0f;
	FVector2D ArrivePosition = -ArriveTangentDir + KeyPosition;

	FVector2D LeavePosition = LeaveTangentDir + KeyPosition;

	Arrive = FVector2D(ScaleInfo.InputToLocalX(ArrivePosition.X), ScaleInfo.OutputToLocalY(ArrivePosition.Y));
	Leave = FVector2D(ScaleInfo.InputToLocalX(LeavePosition.X), ScaleInfo.OutputToLocalY(LeavePosition.Y));

	FVector2D KeyScreenPosition = FVector2D(ScaleInfo.InputToLocalX(KeyPosition.X), ScaleInfo.OutputToLocalY(KeyPosition.Y));

	FVector2D ToArrive = Arrive - KeyScreenPosition;
	ToArrive.Normalize();

	Arrive = KeyScreenPosition + ToArrive*CONST_KeyTangentOffset;

	FVector2D ToLeave = Leave - KeyScreenPosition;
	ToLeave.Normalize();

	Leave = KeyScreenPosition + ToLeave*CONST_KeyTangentOffset;
}

TArray<SCurveEditor::FSelectedCurveKey> SCurveEditor::GetEditableKeysWithinMarquee(const FGeometry& InMyGeometry, FVector2D MarqueeTopLeft, FVector2D MarqueeBottomRight) const
{
	TArray<FSelectedCurveKey> KeysWithinMarquee;
	if (AreCurvesVisible())
	{
		FTrackScaleInfo ScaleInfo(ViewMinInput.Get(), ViewMaxInput.Get(), ViewMinOutput.Get(), ViewMaxOutput.Get(), InMyGeometry.GetLocalSize());
		for (auto CurveViewModel : CurveViewModels)
		{
			if (IsCurveSelectable(CurveViewModel))
			{
				FRealCurve* Curve = CurveViewModel->CurveInfo.CurveToEdit;
				if (Curve != NULL)
				{
					for (auto It(Curve->GetKeyHandleIterator()); It; ++It)
					{
						float KeyScreenX = ScaleInfo.InputToLocalX(Curve->GetKeyTime(*It));
						float KeyScreenY = ScaleInfo.OutputToLocalY(Curve->GetKeyValue(*It));

						if (KeyScreenX >= (MarqueeTopLeft.X - (0.5f * CONST_KeySize.X)) &&
							KeyScreenX <= (MarqueeBottomRight.X + (0.5f * CONST_KeySize.X)) &&
							KeyScreenY >= (MarqueeTopLeft.Y - (0.5f * CONST_KeySize.Y)) &&
							KeyScreenY <= (MarqueeBottomRight.Y + (0.5f * CONST_KeySize.Y)))
						{
							KeysWithinMarquee.Add(FSelectedCurveKey(Curve, *It));
						}
					}
				}
			}
		}
	}

	return KeysWithinMarquee;
}

TArray<SCurveEditor::FSelectedTangent> SCurveEditor::GetEditableTangentsWithinMarquee(const FGeometry& InMyGeometry, FVector2D MarqueeTopLeft, FVector2D MarqueeBottomRight) const
{
	FBox MarqueeBox;
	MarqueeBox.Min = FVector(MarqueeTopLeft.X, MarqueeTopLeft.Y, 0);
	MarqueeBox.Max = FVector(MarqueeBottomRight.X, MarqueeBottomRight.Y, 0);

	TArray<FSelectedTangent> TangentsWithinMarquee;
	if (AreCurvesVisible() && CurveOwner && CurveOwner->HasRichCurves())
	{
		FTrackScaleInfo ScaleInfo(ViewMinInput.Get(), ViewMaxInput.Get(), ViewMinOutput.Get(), ViewMaxOutput.Get(), InMyGeometry.GetLocalSize());
		for (auto CurveViewModel : CurveViewModels)
		{
			if (IsCurveSelectable(CurveViewModel))
			{
				FRichCurve* Curve = (FRichCurve*)CurveViewModel->CurveInfo.CurveToEdit;
				if (Curve != NULL)
				{
					for (auto It(Curve->GetKeyHandleIterator()); It; ++It)
					{
						FKeyHandle KeyHandle = *It;
						FSelectedCurveKey SelectedCurveKey(Curve, KeyHandle);

						if(SelectedCurveKey.IsValid())
						{
							bool bIsTangentSelected = false;
							bool bIsArrivalSelected = false;
							bool bIsLeaveSelected = false;
							bool bIsTangentVisible = IsTangentVisible(Curve, KeyHandle, bIsTangentSelected, bIsArrivalSelected, bIsLeaveSelected);

							if (bIsTangentVisible)
							{
								FVector2D Arrive, Leave;
								GetTangentPoints(ScaleInfo, SelectedCurveKey, Arrive, Leave);

								bool bArriveInside = MarqueeBox.IsInsideOrOn(FVector(Arrive.X, Arrive.Y, 0));
								bool bLeaveInside = MarqueeBox.IsInsideOrOn(FVector(Leave.X, Leave.Y, 0));

								if (bArriveInside || bLeaveInside)
								{
									FSelectedTangent SelectedTangent(SelectedCurveKey);
									SelectedTangent.bIsArrival = bArriveInside;
									TangentsWithinMarquee.Add(SelectedTangent);
								}	
							}
						}
					}
				}
			}
		}
	}
	return TangentsWithinMarquee;
}

void SCurveEditor::BeginDragTransaction()
{
	TransactionIndex = GEditor->BeginTransaction( LOCTEXT("CurveEditor_Drag", "Mouse Drag") );
	CurveOwner->ModifyOwner();
}

void SCurveEditor::EndDragTransaction()
{
	if ( TransactionIndex >= 0 )
	{
		TArray<FRichCurveEditInfo> ChangedCurveEditInfos;

		if (DragState == EDragState::DragKey || DragState == EDragState::FreeDrag)
		{
			for (auto SelectedKey : SelectedKeys)
			{
				ChangedCurveEditInfos.Add(GetViewModelForCurve(SelectedKey.Curve)->CurveInfo);
			}
		}
		else if (DragState == EDragState::DragTangent)
		{
			for (auto SelectedTangent : SelectedTangents)
			{
				ChangedCurveEditInfos.Add(GetViewModelForCurve(SelectedTangent.Key.Curve)->CurveInfo);
			}
		}

		if (ChangedCurveEditInfos.Num())
		{
			CurveOwner->OnCurveChanged(ChangedCurveEditInfos);
		}
		
		GEditor->EndTransaction();
		TransactionIndex = -1;
	}
}

bool SCurveEditor::FSelectedTangent::IsValid() const
{
	return Key.IsValid();
}

void SCurveEditor::UndoAction()
{
	GEditor->UndoTransaction();
}

void SCurveEditor::RedoAction()
{
	GEditor->RedoTransaction();
}

void SCurveEditor::RefreshDetailsView()
{
	check(!bIsPendingRebuilt);

	bIsPendingRebuilt = true;

	//To clean up dangling references
	EmptyAllSelection();
	EmptyAllCurveViewModels();

	// Refresh will still happen in the current frame, but it's important to make it asynchronous because its possible the user sets value through property handle multiple times inside an atomic action
	// Making it synchronous will invalidate property nodes for all the subsequent property handle set value operation.
	RegisterActiveTimer(0.f, FWidgetActiveTimerDelegate::CreateSPLambda(
		this,
		[this](double, float)
		{
			if(const TSharedPtr<IPropertyUtilities> PropertyUtilities = PropertyUtilitiesWeak.Pin())
			{
				//Rebuild the widget so it will reference to the new correct address of Curves, and show things correctly
				PropertyUtilities->ForceRefresh();
			}

			return EActiveTimerReturnType::Stop;
		}
	));

	ValidateSelection();
}

void SCurveEditor::OnObjectPropertyChanged(UObject* Object, FPropertyChangedEvent& PropertyChangedEvent)
{
	if (CurveOwner && CurveOwner->GetOwners().Contains(Object))
	{
		if (!bIsPendingRebuilt)
		{
			if (GIsTransacting)
			{
				RefreshDetailsView();
			}
		}
	}
}

void SCurveEditor::OnRootPropertyChanged(const FPropertyChangedEvent& PropertyChangedEvent)
{
	if (!bIsPendingRebuilt)
	{
		// CurveEditor will hold dangling references to CurveData and access them in some cases :
		// - Curve Data is inline allocated, or wrapped by InstancedStruct, in a container. And we do Array Remove/Clear op, or Add that causes resize
		// - Curve Data is wrapped by InstancedStruct in a Container, and we do undo/redo(will trigger emptying and refilling the container, causing address changed)
		// - Curve Data is wrapped by InstancedStruct and InstancedStruct is being reset/replaced, causing actual memory address changed
		// todo: should only rebuild when it's the InstanceStruct with ValueSet. But currently there is no way to detect if there is an InstanceStruct in the PropertyNode Hierarchy.
		if (PropertyChangedEvent.ChangeType
			& (EPropertyChangeType::ArrayAdd
			| EPropertyChangeType::ArrayRemove
			| EPropertyChangeType::ArrayClear
			| EPropertyChangeType::ValueSet
			| EPropertyChangeType::ResetToDefault))
		{
			RefreshDetailsView();
		}
	}

	ValidateSelection();
}

void SCurveEditor::HandlePackageReloaded(const EPackageReloadPhase InPackageReloadPhase, FPackageReloadedEvent* InPackageReloadedEvent)
{
	if (InPackageReloadPhase == EPackageReloadPhase::OnPackageFixup && CurveOwner)
	{
		// Our curve owner may be an object that has been reloaded, so we need to check that and update the curve editor appropriately
		// We have to do this via the interface as the object addresses stored in the remap table will be offset from the interface pointer due to multiple inheritance
		FCurveOwnerInterface* NewCurveOwner = nullptr;
		if (CurveOwner->RepointCurveOwner(*InPackageReloadedEvent, NewCurveOwner))
		{
			SetCurveOwner(NewCurveOwner, bCanEditTrack);
		}
	}
}

void SCurveEditor::PostUndo(bool bSuccess)
{
	ValidateSelection();
}

bool SCurveEditor::IsLinearColorCurve() const 
{
	return CurveOwner && CurveOwner->IsLinearColorCurve();
}

FVector2D SCurveEditor::SnapLocation(FVector2D InLocation)
{
	if (bInputSnappingEnabled.Get())
	{
		const float InputSnapNow = InputSnap.Get();

		InLocation.X = InputSnapNow != 0 ? FMath::RoundToInt(InLocation.X / InputSnapNow) * InputSnapNow : InLocation.X;
	}

	if (bOutputSnappingEnabled.Get())
	{
		const float OutputSnapNow = OutputSnap.Get();

		InLocation.Y = OutputSnapNow != 0 ? FMath::RoundToInt(InLocation.Y / OutputSnapNow) * OutputSnapNow : InLocation.Y;
	}
	return InLocation;
}

TSharedPtr<FCurveViewModel> SCurveEditor::GetViewModelForCurve(FRealCurve* InCurve)
{
	for (auto CurveViewModel : CurveViewModels)
	{
		if (InCurve == CurveViewModel->CurveInfo.CurveToEdit)
		{
			return CurveViewModel;
		}
	}
	return TSharedPtr<FCurveViewModel>();
}

void SCurveEditor::GenericTextEntryModeless(const FText& DialogText, const FText& DefaultText, FOnTextCommitted OnTextComitted)
{
	TSharedRef<STextEntryPopup> TextEntryPopup = 
		SNew(STextEntryPopup)
		.Label(DialogText)
		.DefaultText(DefaultText)
		.OnTextCommitted(OnTextComitted)
		.ClearKeyboardFocusOnCommit(false)
		.SelectAllTextWhenFocused(true)
		.MaxWidth(1024.0f);

	EntryPopupMenu = FSlateApplication::Get().PushMenu(
		SharedThis(this),
		FWidgetPath(),
		TextEntryPopup,
		FSlateApplication::Get().GetCursorPos(),
		FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup)
	);
}


void SCurveEditor::CloseEntryPopupMenu()
{
	if (EntryPopupMenu.IsValid())
	{
		EntryPopupMenu.Pin()->Dismiss();
	}
}

	
int32 SCurveEditor::TimeToFrame(float InTime) const
{
	const float FrameRate = InputSnap.IsSet() ? 1.0f / InputSnap.Get() : 1.f;
	float Frame = InTime * FrameRate;
	return FMath::RoundToInt(Frame);
}


float SCurveEditor::FrameToTime(int32 InFrame) const
{
	const float FrameRate = InputSnap.IsSet() ? 1.0f / InputSnap.Get() : 1.f;
	return InFrame / FrameRate;
}

#undef LOCTEXT_NAMESPACE