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

#include "SSidebarDrawer.h"
#include "Framework/Application/SlateApplication.h"
#include "Sidebar/SidebarDrawer.h"
#include "Sidebar/SSidebar.h"
#include "Styling/AppStyle.h"
#include "Widgets/Layout/SBox.h"

SSidebarDrawer::~SSidebarDrawer()
{
	FSlateApplication::Get().OnFocusChanging().RemoveAll(this);

	FSlateThrottleManager::Get().LeaveResponsiveMode(AnimationThrottle);
	FSlateThrottleManager::Get().LeaveResponsiveMode(ResizeThrottleHandle);
}

void SSidebarDrawer::Construct(const FArguments& InArgs, const TSharedRef<FSidebarDrawer>& InDrawer, const ESidebarTabLocation InTabLocation)
{
	check(InDrawer->ContentWidget.IsValid());

	DrawerWeak = InDrawer;
	TabLocation = InTabLocation;

	MinDrawerSize = InArgs._MinDrawerSize;
	MaxDrawerSize = InArgs._MaxDrawerSize;
	TargetDrawerSize = FMath::Clamp(InArgs._TargetDrawerSize, MinDrawerSize, MaxDrawerSize);
	ShadowOffset = InArgs._ShadowOffset;
	ExpanderHandleSize = InArgs._ExpanderHandleSize;
	
	OnDrawerSizeChanged = InArgs._OnDrawerSizeChanged;
	OnDrawerFocused = InArgs._OnDrawerFocused;
	OnDrawerFocusLost = InArgs._OnDrawerFocusLost;
	OnCloseAnimationFinish = InArgs._OnCloseAnimationFinish;
	OnOpenAnimationFinish = InArgs._OnOpenAnimationFinish;

	OpenCloseAnimation = FCurveSequence(0.f, AnimationLength, ECurveEaseFunction::QuadOut);

	FSlateApplication::Get().OnFocusChanging().AddSP(this, &SSidebarDrawer::OnGlobalFocusChanging);

	ChildSlot
	[
		SNew(SBox)
		.Clipping(EWidgetClipping::ClipToBounds)
		[
			InDrawer->ContentWidget.ToSharedRef()
		]
	];
}

void SSidebarDrawer::SetCurrentSize(const float InSize)
{
	CurrentSize = FMath::Clamp(InSize, MinDrawerSize, TargetDrawerSize);
}

void SSidebarDrawer::Open(const bool bInAnimateOpen)
{
	if (!bInAnimateOpen)
	{
		SetCurrentSize(TargetDrawerSize);
		OpenCloseAnimation.JumpToEnd();
		return;
	}

	if (OpenCloseAnimation.IsInReverse())
	{
		OpenCloseAnimation.Reverse();
	}

	OpenCloseAnimation.Play(AsShared(), false, OpenCloseAnimation.GetSequenceTime(), false);

	if (!OpenCloseTimer.IsValid())
	{
		AnimationThrottle = FSlateThrottleManager::Get().EnterResponsiveMode();
		OpenCloseTimer = RegisterActiveTimer(0.f, FWidgetActiveTimerDelegate::CreateSP(this, &SSidebarDrawer::UpdateAnimation));
	}
}

void SSidebarDrawer::Close(const bool bInAnimateOpen)
{
	if (!bInAnimateOpen)
	{
		SetCurrentSize(0.f);
		OpenCloseAnimation.JumpToStart();
		return;
	}

	if (OpenCloseAnimation.IsForward())
	{
		OpenCloseAnimation.Reverse();
	}

	if (!OpenCloseTimer.IsValid())
	{
		AnimationThrottle = FSlateThrottleManager::Get().EnterResponsiveMode();
		OpenCloseTimer = RegisterActiveTimer(0.f, FWidgetActiveTimerDelegate::CreateSP(this, &SSidebarDrawer::UpdateAnimation));
	}
}

bool SSidebarDrawer::IsOpen() const
{
	return !OpenCloseAnimation.IsAtStart();
}

bool SSidebarDrawer::IsClosing() const
{
	return OpenCloseAnimation.IsPlaying() && OpenCloseAnimation.IsInReverse();
}

TSharedPtr<FSidebarDrawer> SSidebarDrawer::GetDrawer() const
{
	return DrawerWeak.Pin();
}

bool SSidebarDrawer::SupportsKeyboardFocus() const 
{
	return true;
}

FVector2D SSidebarDrawer::ComputeDesiredSize(const float InLayoutScaleMultiplier) const
{
	switch (TabLocation)
	{
	case ESidebarTabLocation::Left:
	case ESidebarTabLocation::Right:
		return FVector2D(TargetDrawerSize + ShadowOffset.X, 1.f);
	case ESidebarTabLocation::Top:
	case ESidebarTabLocation::Bottom:
		return FVector2D(1.f, TargetDrawerSize + ShadowOffset.Y);
	}
	return FVector2D::One();
}

void SSidebarDrawer::OnArrangeChildren(const FGeometry& InAllottedGeometry, FArrangedChildren& ArrangedChildren) const 
{
	const EVisibility ChildVisibility = ChildSlot.GetWidget()->GetVisibility();
	if (!ArrangedChildren.Accepts(ChildVisibility))
	{
		return;
	}

	FVector2f ChildOffset;
	FVector2f LocalSize;

	switch (TabLocation)
	{
	case ESidebarTabLocation::Left:
		ChildOffset = FVector2f(0.f, ShadowOffset.Y);
		LocalSize = FVector2f(TargetDrawerSize, InAllottedGeometry.GetLocalSize().Y - (ShadowOffset.Y * 2));
		break;
	case ESidebarTabLocation::Right:
		ChildOffset = ShadowOffset;
		LocalSize = FVector2f(TargetDrawerSize, InAllottedGeometry.GetLocalSize().Y - (ShadowOffset.Y * 2));
		break;
	case ESidebarTabLocation::Top:
		ChildOffset = FVector2f(ShadowOffset.X, 0.f);
		LocalSize = FVector2f(InAllottedGeometry.GetLocalSize().X - (ShadowOffset.X * 2), TargetDrawerSize);
		break;
	case ESidebarTabLocation::Bottom:
		ChildOffset = ShadowOffset;
		LocalSize = FVector2f(InAllottedGeometry.GetLocalSize().X - (ShadowOffset.X * 2), TargetDrawerSize);
		break;
	}

	ArrangedChildren.AddWidget(InAllottedGeometry.MakeChild(ChildSlot.GetWidget(), ChildOffset, LocalSize));
}

FReply SSidebarDrawer::OnMouseButtonDown(const FGeometry& InAllottedGeometry, const FPointerEvent& InMouseEvent)
{
	FReply Reply = FReply::Unhandled();

	if (InMouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)
	{
		const FGeometry ResizeHandleGeometry = GetResizeHandleGeometry(InAllottedGeometry);

		if (ResizeHandleGeometry.IsUnderLocation(InMouseEvent.GetScreenSpacePosition()))
		{
			bIsResizing = true;
			InitialResizeGeometry = ResizeHandleGeometry;
			InitialSizeAtResize = CurrentSize;
			ResizeThrottleHandle = FSlateThrottleManager::Get().EnterResponsiveMode();

			Reply = FReply::Handled().CaptureMouse(SharedThis(this));
		}
	}

	return Reply;
}

FReply SSidebarDrawer::OnMouseButtonUp(const FGeometry& InAllottedGeometry, const FPointerEvent& InMouseEvent)
{
	if (bIsResizing && InMouseEvent.GetEffectingButton() == EKeys::LeftMouseButton)
	{
		bIsResizing = false;
		FSlateThrottleManager::Get().LeaveResponsiveMode(ResizeThrottleHandle);

		OnDrawerSizeChanged.ExecuteIfBound(SharedThis(this), TargetDrawerSize);

		return FReply::Handled().ReleaseMouseCapture();
	}

	return FReply::Unhandled();
}

FReply SSidebarDrawer::OnMouseMove(const FGeometry& InAllottedGeometry, const FPointerEvent& InMouseEvent)
{
	const FGeometry ResizeHandleGeometry = GetResizeHandleGeometry(InAllottedGeometry);

	bIsResizeHandleHovered = ResizeHandleGeometry.IsUnderLocation(InMouseEvent.GetScreenSpacePosition());

	if (bIsResizing && this->HasMouseCapture() && !InMouseEvent.GetCursorDelta().IsZero())
	{
		const FVector2f MousePosition = InMouseEvent.GetScreenSpacePosition();
		const FVector2f LocalMousePosition = InitialResizeGeometry.AbsoluteToLocal(MousePosition);

		float DeltaSize = 0.f;

		switch (TabLocation)
		{
		case ESidebarTabLocation::Left:
			DeltaSize = LocalMousePosition.X;
			break;
		case ESidebarTabLocation::Right:
			DeltaSize = -LocalMousePosition.X;
			break;
		case ESidebarTabLocation::Top:
			DeltaSize = LocalMousePosition.Y;
			break;
		case ESidebarTabLocation::Bottom:
			DeltaSize = -LocalMousePosition.Y;
			break;
		}

		TargetDrawerSize = FMath::Clamp(InitialSizeAtResize + DeltaSize, MinDrawerSize, MaxDrawerSize);
		SetCurrentSize(InitialSizeAtResize + DeltaSize);

		return FReply::Handled();
	}

	return FReply::Unhandled();
}

void SSidebarDrawer::OnMouseLeave(const FPointerEvent& InMouseEvent)
{
	SCompoundWidget::OnMouseLeave(InMouseEvent);

	bIsResizeHandleHovered = false;
}

FCursorReply SSidebarDrawer::OnCursorQuery(const FGeometry& InGeometry, const FPointerEvent& InCursorEvent) const
{
	if (bIsResizing || bIsResizeHandleHovered)
	{
		switch (TabLocation)
		{
		case ESidebarTabLocation::Left:
		case ESidebarTabLocation::Right:
			return FCursorReply::Cursor(EMouseCursor::ResizeLeftRight);
		case ESidebarTabLocation::Top:
		case ESidebarTabLocation::Bottom:
			return FCursorReply::Cursor(EMouseCursor::ResizeUpDown);
		}
	}

	return FCursorReply::Unhandled();
}

int32 SSidebarDrawer::OnPaint(const FPaintArgs& InArgs, const FGeometry& InAllottedGeometry, const FSlateRect& InCullingRect
	, FSlateWindowElementList& OutDrawElements, int32 InLayerId, const FWidgetStyle& InWidgetStyle, bool bInParentEnabled) const
{
	static const FSlateBrush* BackgroundBrush = FAppStyle::Get().GetBrush(TEXT("Docking.Sidebar.DrawerBackground"));
	static const FSlateBrush* ShadowBrush = FAppStyle::Get().GetBrush(TEXT("Docking.Sidebar.DrawerShadow"));
	static const FSlateBrush* BorderBrush = FAppStyle::Get().GetBrush(TEXT("Docking.Sidebar.Border"));
	static const FSlateBrush* BorderSquareEdgeBrush;
	switch (TabLocation)
	{
	case ESidebarTabLocation::Left:
		BorderSquareEdgeBrush = FAppStyle::Get().GetBrush(TEXT("Docking.Sidebar.Border_SquareLeft"));
		break;
	case ESidebarTabLocation::Right:
		BorderSquareEdgeBrush = FAppStyle::Get().GetBrush(TEXT("Docking.Sidebar.Border_SquareRight"));
		break;
	case ESidebarTabLocation::Top:
	case ESidebarTabLocation::Bottom:
		// @TODO: There are no existing top or bottom brushes
		BorderSquareEdgeBrush = BorderBrush;
		break;
	}
	static const FSplitterStyle* SplitterStyle = &FAppStyle::Get().GetWidgetStyle<FSplitterStyle>(TEXT("Splitter"));
	static const FSlateColor ShadowColor = FAppStyle::Get().GetSlateColor(TEXT("Colors.Foldout"));

	const FGeometry RenderTransformedChildGeometry = GetRenderTransformedGeometry(InAllottedGeometry);
	const FGeometry ResizeHandleGeometry = GetResizeHandleGeometry(InAllottedGeometry);
	const FVector2f LocalSize = InAllottedGeometry.GetLocalSize();

	FVector2f ContentsLocalOrigin;
	FVector2f ContentsLocalSize;

	switch (TabLocation)
	{
	case ESidebarTabLocation::Left:
		ContentsLocalOrigin = FVector2f(0.f, ShadowOffset.Y);
		ContentsLocalSize = FVector2f(TargetDrawerSize, LocalSize.Y - (ShadowOffset.Y * 2));
		break;
	case ESidebarTabLocation::Right:
		ContentsLocalOrigin = ShadowOffset;
		ContentsLocalSize = FVector2f(TargetDrawerSize, LocalSize.Y - (ShadowOffset.Y * 2));
		break;
	case ESidebarTabLocation::Top:
	case ESidebarTabLocation::Bottom:
		ContentsLocalOrigin = ShadowOffset;
		ContentsLocalSize = FVector2f(LocalSize.X - (ShadowOffset.X * 2), TargetDrawerSize);
		break;
	}

	const FPaintGeometry OffsetPaintGeom = RenderTransformedChildGeometry.ToPaintGeometry(ContentsLocalSize, FSlateLayoutTransform(ContentsLocalOrigin));

	// Draw the resize handle
	if (bIsResizing || bIsResizeHandleHovered)
	{
		const FSlateBrush* SplitterBrush = &SplitterStyle->HandleHighlightBrush;
		FSlateDrawElement::MakeBox(
			OutDrawElements,
			InLayerId,
			ResizeHandleGeometry.ToPaintGeometry(),
			SplitterBrush,
			ESlateDrawEffect::None,
			SplitterBrush->GetTint(InWidgetStyle));
	}

	// Main Shadow
	FSlateDrawElement::MakeBox(
		OutDrawElements,
		InLayerId++,
		RenderTransformedChildGeometry.ToPaintGeometry(),
		ShadowBrush,
		ESlateDrawEffect::None,
		ShadowBrush->GetTint(InWidgetStyle));

	// Background
	FSlateDrawElement::MakeBox(
		OutDrawElements,
		InLayerId++,
		OffsetPaintGeom,
		BackgroundBrush,
		ESlateDrawEffect::None,
		BackgroundBrush->GetTint(InWidgetStyle));

	int32 OutLayerId = SCompoundWidget::OnPaint(InArgs, RenderTransformedChildGeometry, InCullingRect, OutDrawElements, InLayerId, InWidgetStyle, bInParentEnabled);

	TSharedPtr<SWidget> TabButton;
	if (const TSharedPtr<FSidebarDrawer> Drawer = DrawerWeak.Pin())
	{
		TabButton = Drawer->ButtonWidget;
	}
	if (!TabButton.IsValid())
	{
		return ++OutLayerId;
	}

	// Top border
	switch (TabLocation)
	{
	case ESidebarTabLocation::Left:
	case ESidebarTabLocation::Right:
		{
			// Example of how border box is drawn with the tab notch cut out on the right side
			// (OpenDirection == ESidebarTabLocation::Right)
			//
			//                    + - - - - - - +
			//                    : /---------\ :
			// ClipAboveTabButton : |         | : 
			//                    : |         | :
			//            TabTopY + - - - - - - +
			//                    : |           :  |
			// ClipAtTabButton    : |           :  |  (right edge outside clip is clipped off)
			//                    : |           :  |
			//         TabBottomY + - - - - - - +
			//                    : |         | :
			// ClipBelowTabButton : |         | :
			//                    : \---------/ :
			//                    + - - - - - - +
			//                                  <-->
			//                              NotchOffset
			//
			// Originally, I tried making the middle clip region thinner (to clip out the notch)
			// while keeping the geometry identical, but this looks worse when the tab notch needs to
			// be at the top or bottom, since the top/bottom edge of the border wouldn't extend all the
			// way to the edge.
			const FGeometry TabButtonGeometry = TabButton->GetPaintSpaceGeometry();

			// Compute the top/bottom of the tab in our local space.
			const float BorderWidth = BorderBrush->OutlineSettings.Width;
			const float TabTopY = RenderTransformedChildGeometry.AbsoluteToLocal(TabButtonGeometry.GetAbsolutePositionAtCoordinates(FVector2f::ZeroVector)).Y + 0.5f * BorderWidth;
			const float TabBottomY = RenderTransformedChildGeometry.AbsoluteToLocal(TabButtonGeometry.GetAbsolutePositionAtCoordinates(FVector2f::UnitVector)).Y - 0.5f * BorderWidth;

			// Create the geometry for the notched portion, where one edge extends past the clipping rect.
			const FVector2f NotchOffsetSize(TabButtonGeometry.GetLocalSize().X, 0.f);
			const FVector2f NotchOffsetTranslate = TabLocation == ESidebarTabLocation::Left ? -NotchOffsetSize : FVector2f::ZeroVector;
			const FPaintGeometry NotchOffsetPaintGeom = RenderTransformedChildGeometry.ToPaintGeometry(ContentsLocalSize + NotchOffsetSize
				, FSlateLayoutTransform(ContentsLocalOrigin + NotchOffsetTranslate));

			// Split the border box into three clipping zones.
			const FPaintGeometry ClipAboveTabButton = RenderTransformedChildGeometry.ToPaintGeometry(FVector2f(LocalSize.X, TabTopY)
				, FSlateLayoutTransform(FVector2f(0.f, 0.f)));
			const FPaintGeometry ClipAtTabButton = RenderTransformedChildGeometry.ToPaintGeometry(FVector2f(LocalSize.X, TabBottomY - TabTopY)
				, FSlateLayoutTransform(FVector2f(0.f, TabTopY)));
			const FPaintGeometry ClipBelowTabButton = RenderTransformedChildGeometry.ToPaintGeometry(FVector2f(LocalSize.X, LocalSize.Y - TabBottomY)
				, FSlateLayoutTransform(FVector2f(0.f, TabBottomY)));

			// If the tab button touches a corner on the edge of the border, switch the brush to
			// draw that corner squared-off. When a tab is near the very top or bottom of its sidebar,
			// this makes the outline look slightly nicer and more connected.
			const int32 UpperCornerIndex = TabLocation == ESidebarTabLocation::Left ? 0 : 1;
			const int32 LowerCornerIndex = TabLocation == ESidebarTabLocation::Left ? 3 : 2;
			const bool bTabTouchesUpperCorner = TabTopY < ShadowOffset.Y + BorderBrush->OutlineSettings.CornerRadii[UpperCornerIndex];
			const bool bTabTouchesLowerCorner = TabBottomY > LocalSize.Y - ShadowOffset.Y - BorderBrush->OutlineSettings.CornerRadii[LowerCornerIndex];
			const FSlateBrush* AboveTabBrush = bTabTouchesUpperCorner ? BorderSquareEdgeBrush : BorderBrush;
			const FSlateBrush* BelowTabBrush = bTabTouchesLowerCorner ? BorderSquareEdgeBrush : BorderBrush;

			// Draw portion above the tab
			OutDrawElements.PushClip(FSlateClippingZone(ClipAboveTabButton));
			FSlateDrawElement::MakeBox(OutDrawElements, OutLayerId, OffsetPaintGeom, AboveTabBrush
				, ESlateDrawEffect::None, AboveTabBrush->GetTint(InWidgetStyle));
			OutDrawElements.PopClip();

			// Draw "notched" portion next to the tab
			OutDrawElements.PushClip(FSlateClippingZone(ClipAtTabButton));
			FSlateDrawElement::MakeBox(OutDrawElements, OutLayerId, NotchOffsetPaintGeom, BorderSquareEdgeBrush
				, ESlateDrawEffect::None, BorderSquareEdgeBrush->GetTint(InWidgetStyle));
			OutDrawElements.PopClip();

			// Draw portion below the tab
			OutDrawElements.PushClip(FSlateClippingZone(ClipBelowTabButton));
			FSlateDrawElement::MakeBox(OutDrawElements, OutLayerId, OffsetPaintGeom, BelowTabBrush
				, ESlateDrawEffect::None, BelowTabBrush->GetTint(InWidgetStyle));
			OutDrawElements.PopClip();
		}
		break;
	case ESidebarTabLocation::Top:
	case ESidebarTabLocation::Bottom:
		{
			// When opened from the bottom, draw the full border.
			// Cutting out the "notch" for the corresponding tab is only supported in left/right orientations.
			FSlateDrawElement::MakeBox(OutDrawElements, OutLayerId, OffsetPaintGeom, BorderBrush
				, ESlateDrawEffect::None, BorderBrush->GetTint(InWidgetStyle));
		}
		break;
	}

	return ++OutLayerId;
}

FGeometry SSidebarDrawer::GetRenderTransformedGeometry(const FGeometry& InAllottedGeometry) const
{
	switch (TabLocation)
	{
	case ESidebarTabLocation::Left:
		return InAllottedGeometry.MakeChild(FSlateRenderTransform(FVector2f(CurrentSize - TargetDrawerSize, 0.f)));
	case ESidebarTabLocation::Right:
		return InAllottedGeometry.MakeChild(FSlateRenderTransform(FVector2f(TargetDrawerSize - CurrentSize, 0.f)));
	case ESidebarTabLocation::Top:
		return InAllottedGeometry.MakeChild(FSlateRenderTransform(FVector2f(0.f, CurrentSize - TargetDrawerSize)));
	case ESidebarTabLocation::Bottom:
		return InAllottedGeometry.MakeChild(FSlateRenderTransform(FVector2f(0.f, TargetDrawerSize - CurrentSize)));
	}
	return FGeometry();
}

FGeometry SSidebarDrawer::GetResizeHandleGeometry(const FGeometry& InAllottedGeometry) const
{
	const FGeometry RenderTransformedGeometry = GetRenderTransformedGeometry(InAllottedGeometry);

	FVector2f LocalSize;
	FVector2f Translation;

	switch (TabLocation)
	{
	case ESidebarTabLocation::Left:
		LocalSize = FVector2f(ExpanderHandleSize, InAllottedGeometry.GetLocalSize().Y - (ShadowOffset.Y * 2));
		Translation = FVector2f(RenderTransformedGeometry.GetLocalSize().X - ShadowOffset.X, ShadowOffset.Y);
		break;
	case ESidebarTabLocation::Right:
		LocalSize = FVector2f(ExpanderHandleSize, InAllottedGeometry.GetLocalSize().Y - (ShadowOffset.Y * 2));
		Translation = ShadowOffset - FVector2f(ExpanderHandleSize, 0.f);
		break;
	case ESidebarTabLocation::Top:
		LocalSize = FVector2f(InAllottedGeometry.GetLocalSize().X - (ShadowOffset.X * 2), ExpanderHandleSize);
		Translation = FVector2f(ShadowOffset.X, RenderTransformedGeometry.GetLocalSize().Y - ShadowOffset.Y);
		break;
	case ESidebarTabLocation::Bottom:
		LocalSize = FVector2f(InAllottedGeometry.GetLocalSize().X - (ShadowOffset.X * 2), ExpanderHandleSize);
		Translation = ShadowOffset - FVector2f(0.f, ExpanderHandleSize);
		break;
	}

	return RenderTransformedGeometry.MakeChild(LocalSize, FSlateLayoutTransform(Translation));
}

EActiveTimerReturnType SSidebarDrawer::UpdateAnimation(const double InCurrentTime, const float InDeltaTime)
{
	SetCurrentSize(FMath::Lerp(0.f, TargetDrawerSize, OpenCloseAnimation.GetLerp()));

	if (!OpenCloseAnimation.IsPlaying())
	{
		if (OpenCloseAnimation.IsAtStart())
		{
			OnCloseAnimationFinish.ExecuteIfBound(SharedThis(this));
		}
		else if (OpenCloseAnimation.IsAtEnd())
		{
			OnOpenAnimationFinish.ExecuteIfBound(SharedThis(this));
		}

		FSlateThrottleManager::Get().LeaveResponsiveMode(AnimationThrottle);
		OpenCloseTimer.Reset();

		return EActiveTimerReturnType::Stop;
	}

	return EActiveTimerReturnType::Continue;
}

static bool IsLegalWidgetFocused(const FWidgetPath& InFocusPath, const TArrayView<TSharedRef<SWidget>>& InLegalFocusWidgets)
{
	for (const TSharedRef<SWidget>& Widget : InLegalFocusWidgets)
	{
		if (InFocusPath.ContainsWidget(&Widget.Get()))
		{
			return true;
		}
	}

	return false;
}

void SSidebarDrawer::OnGlobalFocusChanging(const FFocusEvent& InFocusEvent
	, const FWeakWidgetPath& InOldFocusedWidgetPath, const TSharedPtr<SWidget>& InOldFocusedWidget
	, const FWidgetPath& InNewFocusedWidgetPath, const TSharedPtr<SWidget>& InNewFocusedWidget)
{
	// Sometimes when dismissing focus can change which will trigger this again
	static bool bIsReEntrant = false;
	if (bIsReEntrant)
	{
		return;
	}
	TGuardValue<bool> ReEntrancyGuard(bIsReEntrant, true);

	const TSharedPtr<FSidebarDrawer> Drawer = DrawerWeak.Pin();

	// Only open drawers that are not docked or pinned need to close the drawer when focus is lost
	if (!Drawer || Drawer->State.bIsDocked || Drawer->State.bIsPinned || !Drawer->bIsOpen)
	{
		return;
	}

	// Do not close due to slow tasks as those opening send window activation events
	if (GIsSlowTask || FSlateApplication::Get().GetActiveModalWindow().IsValid())
	{
		return;
	}

	const TSharedRef<SSidebarDrawer> ThisWidget = SharedThis(this);

	TArray<TSharedRef<SWidget>, TInlineAllocator<4>> LegalFocusWidgets;
	LegalFocusWidgets.Add(ThisWidget);
	LegalFocusWidgets.Add(ChildSlot.GetWidget());
	LegalFocusWidgets.Add(Drawer->ButtonWidget.ToSharedRef());

	bool bShouldLoseFocus = false;

	if (IsLegalWidgetFocused(InNewFocusedWidgetPath, MakeArrayView(LegalFocusWidgets)))
	{
		// New focus is on this tab, so make it active
		if (!IsClosing())
		{
			OnDrawerFocused.ExecuteIfBound(ThisWidget);
		}
	}
	else if (InNewFocusedWidgetPath.IsValid())
	{
		// New focus is on something else, try to check if it's a menu or child window
		const TSharedRef<SWindow> NewWindow = InNewFocusedWidgetPath.GetWindow();
		const TSharedPtr<SWindow> ThisWindow = FSlateApplication::Get().FindWidgetWindow(ThisWidget);

		// See if this is a child window (like a color picker being opened from details), and if so, don't dismiss
		if (!NewWindow->IsDescendantOf(ThisWindow))
		{
			if (const TSharedPtr<SWidget> MenuHost = FSlateApplication::Get().GetMenuHostWidget())
			{
				FWidgetPath MenuHostPath;

				// See if the menu being opened is owned by the drawer contents and if so the menu should not be dismissed
				FSlateApplication::Get().GeneratePathToWidgetUnchecked(MenuHost.ToSharedRef(), MenuHostPath);

				if (!MenuHostPath.ContainsWidget(&ChildSlot.GetWidget().Get()))
				{
					bShouldLoseFocus = true;
				}
			}
			else
			{
				bShouldLoseFocus = true;
			}
		}
	}
	else
	{
		bShouldLoseFocus = true;
	}

	if (bShouldLoseFocus)
	{
		OnDrawerFocusLost.ExecuteIfBound(ThisWidget);
	}
}