/**
* The widget should respond by populating the OutDrawElements array with FDrawElements
* that represent it and any of its children.
*
* @param AllottedGeometry The FGeometry that describes an area in which the widget should appear.
* @param MyClippingRect The clipping rectangle allocated for this widget and its children.
* @param OutDrawElements A list of FDrawElements to populate with the output.
* @param LayerId The Layer onto which this widget should be rendered.
* @param InColorAndOpacity Color and Opacity to be applied to all the descendants of the widget being painted
* @param bParentEnabled True if the parent of this widget is enabled.
*
* @return The maximum layer ID attained by this widget or any of its children.
*/
int32 SCompoundWidget::OnPaint( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
// A CompoundWidget just draws its children
FArrangedChildren ArrangedChildren(EVisibility::Visible);
{
#if SLATE_HD_STATS
SCOPE_CYCLE_COUNTER( STAT_SlateOnPaint_SCompoundWidget );
#endif
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
}
// There may be zero elements in this array if our child collapsed/hidden
if( ArrangedChildren.Num() > 0 )
{
check( ArrangedChildren.Num() == 1 );
FArrangedWidget& TheChild = ArrangedChildren(0);
const FSlateRect ChildClippingRect = AllottedGeometry.GetClippingRect().InsetBy( ChildSlot.SlotPadding.Get() * AllottedGeometry.Scale ).IntersectionWith(MyClippingRect);
FWidgetStyle CompoundedWidgetStyle = FWidgetStyle(InWidgetStyle)
.BlendColorAndOpacityTint(ColorAndOpacity.Get())
.SetForegroundColor( ForegroundColor );
return TheChild.Widget->OnPaint( TheChild.Geometry, ChildClippingRect, OutDrawElements, LayerId + 1, CompoundedWidgetStyle, ShouldBeEnabled( bParentEnabled ) );
}
return LayerId;
}
int32 SGridPanel::OnPaint( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
FArrangedChildren ArrangedChildren(EVisibility::All);
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
// Because we paint multiple children, we must track the maximum layer id that they produced in case one of our parents
// wants to an overlay for all of its contents.
int32 MaxLayerId = LayerId;
// We need to iterate over slots, because slots know the GridLayers. This isn't available in the arranged children.
// Some slots do not show up (they are hidden/collapsed). We need a 2nd index to skip over them.
//
// GridLayers must ensure that everything in LayerN is below LayerN+1. In other words,
// every grid layer group must start at the current MaxLayerId (similar to how SOverlay works).
int32 LastGridLayer = 0;
for (int32 ChildIndex = 0; ChildIndex < Slots.Num(); ++ChildIndex)
{
FArrangedWidget& CurWidget = ArrangedChildren(ChildIndex);
if (CurWidget.Widget->GetVisibility().IsVisible())
{
const FSlot& CurSlot = Slots[ChildIndex];
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith( CurWidget.Geometry.GetClippingRect() );
if ( LastGridLayer != CurSlot.LayerParam )
{
// We starting a new grid layer group?
LastGridLayer = CurSlot.LayerParam;
// Ensure that everything here is drawn on top of
// previously drawn grid content.
LayerId = MaxLayerId+1;
}
const int32 CurWidgetsMaxLayerId = CurWidget.Widget->OnPaint(
CurWidget.Geometry,
ChildClipRect,
OutDrawElements,
LayerId,
InWidgetStyle,
ShouldBeEnabled( bParentEnabled )
);
MaxLayerId = FMath::Max( MaxLayerId, CurWidgetsMaxLayerId );
}
}
//#define LAYOUT_DEBUG
#ifdef LAYOUT_DEBUG
LayerId = LayoutDebugPaint( AllottedGeometry, MyClippingRect, OutDrawElements, LayerId );
#endif
return MaxLayerId;
}
bool UCanvasPanel::GetGeometryForSlot(UCanvasPanelSlot* Slot, FGeometry& ArrangedGeometry) const
{
if ( Slot->Content == NULL )
{
return false;
}
TSharedPtr<SConstraintCanvas> Canvas = GetCanvasWidget();
if ( Canvas.IsValid() )
{
FArrangedChildren ArrangedChildren(EVisibility::All);
Canvas->ArrangeChildren(Canvas->GetCachedGeometry(), ArrangedChildren);
for ( int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ChildIndex++ )
{
if ( ArrangedChildren[ChildIndex].Widget == Slot->Content->TakeWidget() )
{
ArrangedGeometry = ArrangedChildren[ChildIndex].Geometry;
return true;
}
}
}
return false;
}
/**
* This widget was created before render transforms existed for each widget, and it chose to apply the render transform AFTER the layout transform.
* This means leveraging the render transform of FGeometry would be expensive, as we would need to use Concat(LayoutTransform, RenderTransform, Inverse(LayoutTransform).
* Instead, we maintain the old way of doing it by modifying the AllottedGeometry only during rendering to append the widget's implied RenderTransform to the existing LayoutTransform.
*/
int32 SFxWidget::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
// Convert the 0..1 origin into local space extents.
const FVector2D ScaleOrigin = RenderScaleOrigin.Get() * AllottedGeometry.Size;
const FVector2D Offset = VisualOffset.Get() * AllottedGeometry.Size;
// create the render transform as a scale around ScaleOrigin and offset it by Offset.
const auto RenderTransform = Concatenate(Inverse(ScaleOrigin), RenderScale.Get(), ScaleOrigin, Offset);
// This will append the render transform to the layout transform, and we only use it for rendering.
FGeometry ModifiedGeometry = AllottedGeometry.MakeChild(AllottedGeometry.Size, RenderTransform);
FArrangedChildren ArrangedChildren(EVisibility::Visible);
this->ArrangeChildren(ModifiedGeometry, ArrangedChildren);
// There may be zero elements in this array if our child collapsed/hidden
if( ArrangedChildren.Num() > 0 )
{
// We can only have one direct descendant.
check( ArrangedChildren.Num() == 1 );
const FArrangedWidget& TheChild = ArrangedChildren[0];
// SFxWidgets are able to ignore parent clipping.
const FSlateRect ChildClippingRect = (bIgnoreClipping.Get())
? ModifiedGeometry.GetClippingRect()
: MyClippingRect.IntersectionWith(ModifiedGeometry.GetClippingRect());
FWidgetStyle CompoundedWidgetStyle = FWidgetStyle(InWidgetStyle)
.BlendColorAndOpacityTint(ColorAndOpacity.Get())
.SetForegroundColor( ForegroundColor );
return TheChild.Widget->Paint( Args.WithNewParent(this), TheChild.Geometry, ChildClippingRect, OutDrawElements, LayerId + 1, CompoundedWidgetStyle, ShouldBeEnabled( bParentEnabled ) );
}
return LayerId;
}
void SClippingHorizontalBox::Tick( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime )
{
// Call ArrangeChildren so we can cache off the index of the first clipped tab
FArrangedChildren ArrangedChildren(EVisibility::Visible);
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
ClippedIdx = ArrangedChildren.Num() - 1;
}
void SWidget::FindChildGeometries_Helper( const FGeometry& MyGeometry, const TSet< TSharedRef<SWidget> >& WidgetsToFind, TMap<TSharedRef<SWidget>, FArrangedWidget>& OutResult ) const
{
// Perform a breadth first search!
FArrangedChildren ArrangedChildren(EVisibility::Visible);
this->ArrangeChildren( MyGeometry, ArrangedChildren );
const int32 NumChildren = ArrangedChildren.Num();
// See if we found any of the widgets on this level.
for(int32 ChildIndex=0; ChildIndex < NumChildren; ++ChildIndex )
{
const FArrangedWidget& CurChild = ArrangedChildren[ ChildIndex ];
if ( WidgetsToFind.Contains(CurChild.Widget) )
{
// We found one of the widgets for which we need geometry!
OutResult.Add( CurChild.Widget, CurChild );
}
}
// If we have not found all the widgets that we were looking for, descend.
if ( OutResult.Num() != WidgetsToFind.Num() )
{
// Look for widgets among the children.
for( int32 ChildIndex=0; ChildIndex < NumChildren; ++ChildIndex )
{
const FArrangedWidget& CurChild = ArrangedChildren[ ChildIndex ];
CurChild.Widget->FindChildGeometries_Helper( CurChild.Geometry, WidgetsToFind, OutResult );
}
}
}
/** SWidget Interface */
int32 SSequencerSectionAreaView::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
FArrangedChildren ArrangedChildren(EVisibility::Visible);
ArrangeChildren(AllottedGeometry, ArrangedChildren);
if( SectionAreaNode.IsValid() )
{
// Draw a region around the entire section area
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(),
BackgroundBrush,
MyClippingRect,
ESlateDrawEffect::None,
SequencerSectionAreaConstants::BackgroundColor
);
}
for (int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
FArrangedWidget& CurWidget = ArrangedChildren[ChildIndex];
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith( CurWidget.Geometry.GetClippingRect() );
const int32 CurWidgetsMaxLayerId = CurWidget.Widget->Paint( Args.WithNewParent(this), CurWidget.Geometry, ChildClipRect, OutDrawElements, LayerId+1, InWidgetStyle, ShouldBeEnabled( bParentEnabled ) );
}
return LayerId+1;
}
int32 SSplitter::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
FArrangedChildren ArrangedChildren( EVisibility::Visible );
ArrangeChildren( AllottedGeometry, ArrangedChildren );
int32 MaxLayerId = PaintArrangedChildren( Args, ArrangedChildren, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled );
const FSlateBrush* NormalHandleBrush = &Style->HandleNormalBrush;
// Draw the splitter above any children
MaxLayerId += 1;
for( int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex )
{
const FGeometry& GeometryAfterSplitter = ArrangedChildren[ FMath::Clamp(ChildIndex + 1, 0, ArrangedChildren.Num()-1) ].Geometry;
const float HalfHitDetectionSplitterHandleSize = ( HitDetectionSplitterHandleSize / 2 );
const float HalfPhysicalSplitterHandleSize = ( PhysicalSplitterHandleSize / 2 );
FVector2D HandleSize;
FVector2D HandlePosition;
if ( Orientation == Orient_Horizontal )
{
HandleSize.Set( PhysicalSplitterHandleSize, GeometryAfterSplitter.Size.Y );
HandlePosition.Set( -(HalfHitDetectionSplitterHandleSize + HalfPhysicalSplitterHandleSize), 0 );
}
else
{
HandleSize.Set( GeometryAfterSplitter.Size.X, PhysicalSplitterHandleSize );
HandlePosition.Set( 0, -(HalfHitDetectionSplitterHandleSize + HalfPhysicalSplitterHandleSize) );
}
if (HoveredHandleIndex != ChildIndex)
{
FSlateDrawElement::MakeBox(
OutDrawElements,
MaxLayerId,
GeometryAfterSplitter.ToPaintGeometry( HandlePosition, HandleSize, 1.0f ),
NormalHandleBrush,
MyClippingRect,
ShouldBeEnabled( bParentEnabled ),
InWidgetStyle.GetColorAndOpacityTint() * NormalHandleBrush->TintColor.GetSpecifiedColor()
);
}
else
{
FSlateDrawElement::MakeBox(
OutDrawElements,
MaxLayerId,
GeometryAfterSplitter.ToPaintGeometry( HandlePosition, HandleSize, 1.0f ),
&Style->HandleHighlightBrush,
MyClippingRect,
ShouldBeEnabled( bParentEnabled ),
InWidgetStyle.GetColorAndOpacityTint() * Style->HandleHighlightBrush.TintColor.GetSpecifiedColor()
);
}
}
return MaxLayerId;
}
int32 SDockingTabWell::OnPaint( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
// When we are dragging a tab, it must be painted on top of the other tabs, so we cannot
// just reuse the Panel's default OnPaint.
// The TabWell has no visualization of its own; it just visualizes its child tabs.
FArrangedChildren ArrangedChildren(EVisibility::Visible);
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
// Because we paint multiple children, we must track the maximum layer id that they produced in case one of our parents
// wants to an overlay for all of its contents.
int32 MaxLayerId = LayerId;
TSharedPtr<SDockTab> ForegroundTab = GetForegroundTab();
FArrangedWidget* ForegroundTabGeometry = NULL;
// Draw all inactive tabs first
for (int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
FArrangedWidget& CurWidget = ArrangedChildren(ChildIndex);
if (CurWidget.Widget == ForegroundTab)
{
ForegroundTabGeometry = &CurWidget;
}
else
{
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith( CurWidget.Geometry.GetClippingRect() );
const int32 CurWidgetsMaxLayerId = CurWidget.Widget->OnPaint( CurWidget.Geometry, ChildClipRect, OutDrawElements, MaxLayerId, InWidgetStyle, ShouldBeEnabled( bParentEnabled ) );
MaxLayerId = FMath::Max( MaxLayerId, CurWidgetsMaxLayerId );
}
}
// Draw active tab in front
if (ForegroundTab != TSharedPtr<SDockTab>())
{
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith( ForegroundTabGeometry->Geometry.GetClippingRect() );
const int32 CurWidgetsMaxLayerId = ForegroundTabGeometry->Widget->OnPaint( ForegroundTabGeometry->Geometry, ChildClipRect, OutDrawElements, MaxLayerId, InWidgetStyle, ShouldBeEnabled( bParentEnabled ) );
MaxLayerId = FMath::Max( MaxLayerId, CurWidgetsMaxLayerId );
}
return MaxLayerId;
}
int32 SClippingHorizontalBox::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
// Get the clipped children info
FArrangedChildren ClippedArrangedChildren(EVisibility::Visible);
ArrangeChildren(AllottedGeometry, ClippedArrangedChildren);
// Get the non-clipped children info
// @todo umg: One should not call the virtual OnArrangeChildren, one should only call ArrangeChildren.
FArrangedChildren ArrangedChildren(EVisibility::Visible);
SBoxPanel::OnArrangeChildren(AllottedGeometry, ArrangedChildren);
if ((ClippedArrangedChildren.Num() != 0) && (ArrangedChildren.Num() != 0))
{
int32 IndexClippedAt = ClippedArrangedChildren.Num() - 1;
const FArrangedWidget& LastCippedChild = ClippedArrangedChildren[IndexClippedAt];
const FArrangedWidget& FirstChild = ArrangedChildren[0];
const FArrangedWidget& LastChild = ArrangedChildren[ArrangedChildren.Num() - 1];
float BorderLocalWidth = AllottedGeometry.Size.X;
// If only the last child/block, which is the wrap button, is being clipped
if (IndexClippedAt == ArrangedChildren.Num() - 2)
{
// Only recalculate the alloted geometry size if said size is fitted to the toolbar/menubar
if (FMath::TruncToInt(AllottedGeometry.AbsolutePosition.X + AllottedGeometry.Size.X * AllottedGeometry.Scale) <= FMath::TruncToInt(LastChild.Geometry.AbsolutePosition.X + LastChild.Geometry.Size.X * LastChild.Geometry.Scale))
{
// Calculate the size of the custom border
BorderLocalWidth = (LastCippedChild.Geometry.AbsolutePosition.X + LastCippedChild.Geometry.Size.X * LastCippedChild.Geometry.Scale - FirstChild.Geometry.AbsolutePosition.X) / AllottedGeometry.Scale;
}
}
else
{
// Children/blocks are being clipped, calculate the size of the custom border
const FArrangedWidget& NextChild = (IndexClippedAt + 1 < ClippedArrangedChildren.Num())? ClippedArrangedChildren[IndexClippedAt + 1]: LastCippedChild;
BorderLocalWidth = (NextChild.Geometry.AbsolutePosition.X + NextChild.Geometry.Size.X * NextChild.Geometry.Scale - FirstChild.Geometry.AbsolutePosition.X) / AllottedGeometry.Scale;
}
bool bEnabled = ShouldBeEnabled( bParentEnabled );
ESlateDrawEffect::Type DrawEffects = !bEnabled ? ESlateDrawEffect::DisabledEffect : ESlateDrawEffect::None;
FSlateColor BorderBackgroundColor = FLinearColor::White;
// Draw the custom border
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(FVector2D(BorderLocalWidth, AllottedGeometry.Size.Y), FSlateLayoutTransform()),
BackgroundBrush,
MyClippingRect,
DrawEffects,
BackgroundBrush->GetTint( InWidgetStyle ) * InWidgetStyle.GetColorAndOpacityTint() * BorderBackgroundColor.GetColor(InWidgetStyle)
);
}
return SHorizontalBox::OnPaint(Args, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
}
int32 SPanel::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
// REMOVE THIS: Currently adding a debug quad so that BoxPanels are visible during development
// OutDrawElements.AddItem( FSlateDrawElement::MakeQuad( AllottedGeometry.AbsolutePosition, AllottedGeometry.Size ) );
FArrangedChildren ArrangedChildren(EVisibility::Visible);
{
// The box panel has no visualization of its own; it just visualizes its children.
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
}
return PaintArrangedChildren(Args, ArrangedChildren, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
}
UWidgetReflectorNodeBase* FWidgetReflectorNodeUtils::NewNodeTreeFrom(const TSubclassOf<UWidgetReflectorNodeBase>& InNodeClass, const FArrangedWidget& InWidgetGeometry)
{
UWidgetReflectorNodeBase* NewNodeInstance = NewNode(InNodeClass, InWidgetGeometry);
FArrangedChildren ArrangedChildren(EVisibility::All);
InWidgetGeometry.Widget->ArrangeChildren(InWidgetGeometry.Geometry, ArrangedChildren);
for (int32 WidgetIndex = 0; WidgetIndex < ArrangedChildren.Num(); ++WidgetIndex)
{
// Note that we include both visible and invisible children!
NewNodeInstance->AddChildNode(NewNodeTreeFrom(InNodeClass, ArrangedChildren[WidgetIndex]));
}
return NewNodeInstance;
}
int32 SMenuAnchor::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
FArrangedChildren ArrangedChildren( EVisibility::Visible );
ArrangeChildren( AllottedGeometry, ArrangedChildren );
// There may be zero elements in this array if our child collapsed/hidden
if ( ArrangedChildren.Num() > 0 )
{
const FArrangedWidget& FirstChild = ArrangedChildren[0];
// In the case where the user doesn't provide content to the menu anchor, the null widget
// wont appear in the visible set of arranged children, so only immediately paint the first child,
// if it's visible and matches the first slot content.
const bool bHasArrangedAnchorContent = FirstChild.Widget == Children[0].GetWidget();
if ( bHasArrangedAnchorContent )
{
const FSlateRect ChildClippingRect = AllottedGeometry.GetClippingRect().IntersectionWith(MyClippingRect);
LayerId = FirstChild.Widget->Paint(Args.WithNewParent(this), FirstChild.Geometry, ChildClippingRect, OutDrawElements, LayerId + 1, InWidgetStyle, ShouldBeEnabled(bParentEnabled));
}
const bool bIsOpen = IsOpen();
if ( bIsOpen )
{
// In the case where the anchor content is present and visible, it's the 1 index child, in the case
// where the anchor content is invisible, it's the 0 index child.
FArrangedWidget* PopupChild = nullptr;
if ( bHasArrangedAnchorContent && ArrangedChildren.Num() > 1 )
{
PopupChild = &ArrangedChildren[1];
}
else if ( !bHasArrangedAnchorContent && ArrangedChildren.Num() == 1 )
{
PopupChild = &ArrangedChildren[0];
}
if ( PopupChild != nullptr )
{
OutDrawElements.QueueDeferredPainting(
FSlateWindowElementList::FDeferredPaint(PopupChild->Widget, Args, PopupChild->Geometry, MyClippingRect, InWidgetStyle, bParentEnabled));
}
}
}
return LayerId;
}
int32 SBox::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
// An SBox just draws its only child
FArrangedChildren ArrangedChildren(EVisibility::Visible);
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
// Maybe none of our children are visible
if( ArrangedChildren.Num() > 0 )
{
check( ArrangedChildren.Num() == 1 );
FArrangedWidget& TheChild = ArrangedChildren[0];
const FSlateRect ChildClippingRect = AllottedGeometry.GetClippingRect().InsetBy( ChildSlot.SlotPadding.Get() * AllottedGeometry.Scale ).IntersectionWith(MyClippingRect);
return TheChild.Widget->Paint( Args.WithNewParent(this), TheChild.Geometry, ChildClippingRect, OutDrawElements, LayerId, InWidgetStyle, ShouldBeEnabled( bParentEnabled ) );
}
return LayerId;
}
int32 SConstraintCanvas::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
FArrangedChildren ArrangedChildren(EVisibility::Visible);
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
// Because we paint multiple children, we must track the maximum layer id that they produced in case one of our parents
// wants to an overlay for all of its contents.
int32 MaxLayerId = LayerId;
for (int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
FArrangedWidget& CurWidget = ArrangedChildren[ChildIndex];
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith(CurWidget.Geometry.GetClippingRect());
const int32 CurWidgetsMaxLayerId = CurWidget.Widget->Paint( Args.WithNewParent(this), CurWidget.Geometry, ChildClipRect, OutDrawElements, MaxLayerId + 1, InWidgetStyle, ShouldBeEnabled(bParentEnabled));
MaxLayerId = FMath::Max(MaxLayerId, CurWidgetsMaxLayerId);
}
return MaxLayerId;
}
int32 SPopup::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
FArrangedChildren ArrangedChildren(EVisibility::Visible);
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
// There may be zero elements in this array if our child collapsed/hidden
if (ArrangedChildren.Num() > 0)
{
check(ArrangedChildren.Num() == 1);
FArrangedWidget& TheChild = ArrangedChildren[0];
FWidgetStyle CompoundedWidgetStyle = FWidgetStyle(InWidgetStyle)
.BlendColorAndOpacityTint(ColorAndOpacity.Get())
.SetForegroundColor(GetForegroundColor());
// An SPopup just queues up its children to be painted after everything in this window is done painting.
OutDrawElements.QueueDeferredPainting(
FSlateWindowElementList::FDeferredPaint(TheChild.Widget, Args.WithNewParent(this), TheChild.Geometry, MyClippingRect, CompoundedWidgetStyle, ShouldBeEnabled(bParentEnabled))
);
}
return LayerId;
}
int32 SResponsiveGridPanel::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
FArrangedChildren ArrangedChildren(EVisibility::All);
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
// Because we paint multiple children, we must track the maximum layer id that they produced in case one of our parents
// wants to an overlay for all of its contents.
int32 MaxLayerId = LayerId;
// We need to iterate over slots, because slots know the GridLayers. This isn't available in the arranged children.
// Some slots do not show up (they are hidden/collapsed). We need a 2nd index to skip over them.
for (int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
FArrangedWidget& CurWidget = ArrangedChildren[ChildIndex];
if (CurWidget.Widget->GetVisibility().IsVisible())
{
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith( CurWidget.Geometry.GetClippingRect() );
const int32 CurWidgetsMaxLayerId = CurWidget.Widget->Paint(
Args.WithNewParent(this),
CurWidget.Geometry,
ChildClipRect,
OutDrawElements,
LayerId,
InWidgetStyle,
ShouldBeEnabled( bParentEnabled )
);
MaxLayerId = FMath::Max( MaxLayerId, CurWidgetsMaxLayerId );
}
}
#ifdef LAYOUT_DEBUG
LayerId = LayoutDebugPaint( AllottedGeometry, MyClippingRect, OutDrawElements, LayerId );
#endif
return MaxLayerId;
}
int32 SSequencerTrackArea::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
FArrangedChildren ArrangedChildren(EVisibility::Visible);
ArrangeChildren(AllottedGeometry, ArrangedChildren);
for (int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
FArrangedWidget& CurWidget = ArrangedChildren[ChildIndex];
FSlateRect ChildClipRect = MyClippingRect.IntersectionWith( CurWidget.Geometry.GetClippingRect() );
const int32 ThisWidgetLayerId = CurWidget.Widget->Paint( Args.WithNewParent(this), CurWidget.Geometry, ChildClipRect, OutDrawElements, LayerId + 1, InWidgetStyle, ShouldBeEnabled( bParentEnabled ) );
LayerId = FMath::Max(LayerId, ThisWidgetLayerId);
}
auto SequencerPin = SequencerWidget.Pin();
if (SequencerPin.IsValid())
{
return SequencerPin->GetEditTool().OnPaint(AllottedGeometry, MyClippingRect, OutDrawElements, LayerId + 1);
}
return LayerId;
}
int32 SWeakWidget::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
// Just draw the children.
FArrangedChildren ArrangedChildren(EVisibility::Visible);
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
// There may be zero elements in this array if our child collapsed/hidden
if( ArrangedChildren.Num() > 0 )
{
check( ArrangedChildren.Num() == 1 );
FArrangedWidget& TheChild = ArrangedChildren[0];
return TheChild.Widget->Paint(
Args.WithNewParent(this),
TheChild.Geometry,
MyClippingRect,
OutDrawElements,
LayerId + 1,
InWidgetStyle,
ShouldBeEnabled( bParentEnabled ) );
}
return LayerId;
}
void SWidget::TickWidgetsRecursively( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime )
{
INC_DWORD_STAT(STAT_SlateNumTickedWidgets);
// Execute any pending active timers for this widget, followed by the passive tick
ExecuteActiveTimers( InCurrentTime, InDeltaTime );
{
SLATE_CYCLE_COUNTER_SCOPE_CUSTOM_DETAILED(SLATE_STATS_DETAIL_LEVEL_MED, GSlateWidgetTick, GetType());
Tick(AllottedGeometry, InCurrentTime, InDeltaTime);
}
// Gather all children, whether they're visible or not. We need to allow invisible widgets to
// consider whether they should still be invisible in their tick functions, as well as maintain
// other state when hidden,
FArrangedChildren ArrangedChildren(TickInvisibleWidgets.GetValueOnGameThread() ? EVisibility::All : EVisibility::Visible);
ArrangeChildren(AllottedGeometry, ArrangedChildren);
// Recur!
for(int32 ChildIndex=0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
FArrangedWidget& SomeChild = ArrangedChildren[ChildIndex];
SomeChild.Widget->TickWidgetsRecursively( SomeChild.Geometry, InCurrentTime, InDeltaTime );
}
}
int32 SGraphPanel::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
#if SLATE_HD_STATS
SCOPE_CYCLE_COUNTER( STAT_SlateOnPaint_SGraphPanel );
#endif
CachedAllottedGeometryScaledSize = AllottedGeometry.Size * AllottedGeometry.Scale;
//Style used for objects that are the same between revisions
FWidgetStyle FadedStyle = InWidgetStyle;
FadedStyle.BlendColorAndOpacityTint(FLinearColor(0.45f,0.45f,0.45f,0.45f));
// First paint the background
const UEditorExperimentalSettings& Options = *GetDefault<UEditorExperimentalSettings>();
const FSlateBrush* BackgroundImage = FEditorStyle::GetBrush(TEXT("Graph.Panel.SolidBackground"));
PaintBackgroundAsLines(BackgroundImage, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId);
const float ZoomFactor = AllottedGeometry.Scale * GetZoomAmount();
FArrangedChildren ArrangedChildren(EVisibility::Visible);
ArrangeChildNodes(AllottedGeometry, ArrangedChildren);
// Determine some 'global' settings based on current LOD
const bool bDrawShadowsThisFrame = GetCurrentLOD() > EGraphRenderingLOD::LowestDetail;
// Because we paint multiple children, we must track the maximum layer id that they produced in case one of our parents
// wants to an overlay for all of its contents.
// Save LayerId for comment boxes to ensure they always appear below nodes & wires
const int32 CommentNodeShadowLayerId = LayerId++;
const int32 CommentNodeLayerId = LayerId++;
// Save a LayerId for wires, which appear below nodes but above comments
// We will draw them later, along with the arrows which appear above nodes.
const int32 WireLayerId = LayerId++;
const int32 NodeShadowsLayerId = LayerId;
const int32 NodeLayerId = NodeShadowsLayerId + 1;
int32 MaxLayerId = NodeLayerId;
const FVector2D NodeShadowSize = GetDefault<UGraphEditorSettings>()->GetShadowDeltaSize();
const UEdGraphSchema* Schema = GraphObj->GetSchema();
// Draw the child nodes
{
// When drawing a marquee, need a preview of what the selection will be.
const FGraphPanelSelectionSet* SelectionToVisualize = &(SelectionManager.SelectedNodes);
FGraphPanelSelectionSet SelectionPreview;
if ( Marquee.IsValid() )
{
ApplyMarqueeSelection(Marquee, SelectionManager.SelectedNodes, SelectionPreview);
SelectionToVisualize = &SelectionPreview;
}
// Context for rendering node infos
FKismetNodeInfoContext Context(GraphObj);
TArray<FGraphDiffControl::FNodeMatch> NodeMatches;
for (int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
FArrangedWidget& CurWidget = ArrangedChildren[ChildIndex];
TSharedRef<SGraphNode> ChildNode = StaticCastSharedRef<SGraphNode>(CurWidget.Widget);
// Examine node to see what layers we should be drawing in
int32 ShadowLayerId = NodeShadowsLayerId;
int32 ChildLayerId = NodeLayerId;
// If a comment node, draw in the dedicated comment slots
{
UObject* NodeObj = ChildNode->GetObjectBeingDisplayed();
if (NodeObj && NodeObj->IsA(UEdGraphNode_Comment::StaticClass()))
{
ShadowLayerId = CommentNodeShadowLayerId;
ChildLayerId = CommentNodeLayerId;
}
}
const bool bNodeIsVisible = FSlateRect::DoRectanglesIntersect( CurWidget.Geometry.GetClippingRect(), MyClippingRect );
if (bNodeIsVisible)
{
const bool bSelected = SelectionToVisualize->Contains( StaticCastSharedRef<SNodePanel::SNode>(CurWidget.Widget)->GetObjectBeingDisplayed() );
// Handle Node renaming once the node is visible
if( bSelected && ChildNode->IsRenamePending() )
{
ChildNode->ApplyRename();
}
// Draw the node's shadow.
if (bDrawShadowsThisFrame || bSelected)
{
const FSlateBrush* ShadowBrush = ChildNode->GetShadowBrush(bSelected);
FSlateDrawElement::MakeBox(
OutDrawElements,
ShadowLayerId,
CurWidget.Geometry.ToInflatedPaintGeometry(NodeShadowSize),
ShadowBrush,
MyClippingRect
);
}
// Draw the comments and information popups for this node, if it has any.
{
const SNodePanel::SNode::FNodeSlot& CommentSlot = ChildNode->GetOrAddSlot( ENodeZone::TopCenter );
float CommentBubbleY = -CommentSlot.Offset.Get().Y;
Context.bSelected = bSelected;
TArray<FGraphInformationPopupInfo> Popups;
{
ChildNode->GetNodeInfoPopups(&Context, /*out*/ Popups);
}
for (int32 PopupIndex = 0; PopupIndex < Popups.Num(); ++PopupIndex)
{
FGraphInformationPopupInfo& Popup = Popups[PopupIndex];
PaintComment(Popup.Message, CurWidget.Geometry, MyClippingRect, OutDrawElements, ChildLayerId, Popup.BackgroundColor, /*inout*/ CommentBubbleY, InWidgetStyle);
}
}
int32 CurWidgetsMaxLayerId;
{
UEdGraphNode* NodeObj = Cast<UEdGraphNode>(ChildNode->GetObjectBeingDisplayed());
/** When diffing nodes, nodes that are different between revisions are opaque, nodes that have not changed are faded */
FGraphDiffControl::FNodeMatch NodeMatch = FGraphDiffControl::FindNodeMatch(GraphObjToDiff, NodeObj, NodeMatches);
if (NodeMatch.IsValid())
{
NodeMatches.Add(NodeMatch);
}
const bool bNodeIsDifferent = (!GraphObjToDiff || NodeMatch.Diff());
/* When dragging off a pin, we want to duck the alpha of some nodes */
TSharedPtr< SGraphPin > OnlyStartPin = (1 == PreviewConnectorFromPins.Num()) ? PreviewConnectorFromPins[0].FindInGraphPanel(*this) : TSharedPtr< SGraphPin >();
const bool bNodeIsNotUsableInCurrentContext = Schema->FadeNodeWhenDraggingOffPin(NodeObj, OnlyStartPin.IsValid() ? OnlyStartPin.Get()->GetPinObj() : NULL);
const FWidgetStyle& NodeStyleToUse = (bNodeIsDifferent && !bNodeIsNotUsableInCurrentContext)? InWidgetStyle : FadedStyle;
// Draw the node.O
CurWidgetsMaxLayerId = CurWidget.Widget->Paint( Args.WithNewParent(this), CurWidget.Geometry, MyClippingRect, OutDrawElements, ChildLayerId, NodeStyleToUse, ShouldBeEnabled( bParentEnabled ) );
}
// Draw the node's overlay, if it has one.
{
// Get its size
const FVector2D WidgetSize = CurWidget.Geometry.Size;
{
TArray<FOverlayBrushInfo> OverlayBrushes;
ChildNode->GetOverlayBrushes(bSelected, WidgetSize, /*out*/ OverlayBrushes);
for (int32 BrushIndex = 0; BrushIndex < OverlayBrushes.Num(); ++BrushIndex)
{
FOverlayBrushInfo& OverlayInfo = OverlayBrushes[BrushIndex];
const FSlateBrush* OverlayBrush = OverlayInfo.Brush;
if(OverlayBrush != NULL)
{
FPaintGeometry BouncedGeometry = CurWidget.Geometry.ToPaintGeometry(OverlayInfo.OverlayOffset, OverlayBrush->ImageSize, 1.f);
// Handle bouncing
const float BounceValue = FMath::Sin(2.0f * PI * BounceCurve.GetLerpLooping());
BouncedGeometry.DrawPosition += (OverlayInfo.AnimationEnvelope * BounceValue * ZoomFactor);
CurWidgetsMaxLayerId++;
FSlateDrawElement::MakeBox(
OutDrawElements,
CurWidgetsMaxLayerId,
BouncedGeometry,
OverlayBrush,
MyClippingRect
);
}
}
}
{
TArray<FOverlayWidgetInfo> OverlayWidgets = ChildNode->GetOverlayWidgets(bSelected, WidgetSize);
for (int32 WidgetIndex = 0; WidgetIndex < OverlayWidgets.Num(); ++WidgetIndex)
{
FOverlayWidgetInfo& OverlayInfo = OverlayWidgets[WidgetIndex];
if(OverlayInfo.Widget->GetVisibility() == EVisibility::Visible)
{
// call SlatePrepass as these widgets are not in the 'normal' child hierarchy
OverlayInfo.Widget->SlatePrepass();
const FGeometry WidgetGeometry = CurWidget.Geometry.MakeChild(OverlayInfo.OverlayOffset, OverlayInfo.Widget->GetDesiredSize(), 1.f);
OverlayInfo.Widget->Paint(Args.WithNewParent(this), WidgetGeometry, MyClippingRect, OutDrawElements, CurWidgetsMaxLayerId, InWidgetStyle, bParentEnabled);
}
}
}
}
MaxLayerId = FMath::Max( MaxLayerId, CurWidgetsMaxLayerId + 1 );
}
}
}
MaxLayerId += 1;
// Draw connections between pins
if (Children.Num() > 0 )
{
//@TODO: Pull this into a factory like the pin and node ones
FConnectionDrawingPolicy* ConnectionDrawingPolicy;
{
ConnectionDrawingPolicy = Schema->CreateConnectionDrawingPolicy(WireLayerId, MaxLayerId, ZoomFactor, MyClippingRect, OutDrawElements, GraphObj);
if (!ConnectionDrawingPolicy)
{
if (Schema->IsA(UAnimationGraphSchema::StaticClass()))
{
ConnectionDrawingPolicy = new FAnimGraphConnectionDrawingPolicy(WireLayerId, MaxLayerId, ZoomFactor, MyClippingRect, OutDrawElements, GraphObj);
}
else if (Schema->IsA(UAnimationStateMachineSchema::StaticClass()))
{
ConnectionDrawingPolicy = new FStateMachineConnectionDrawingPolicy(WireLayerId, MaxLayerId, ZoomFactor, MyClippingRect, OutDrawElements, GraphObj);
}
else if (Schema->IsA(UEdGraphSchema_K2::StaticClass()))
{
ConnectionDrawingPolicy = new FKismetConnectionDrawingPolicy(WireLayerId, MaxLayerId, ZoomFactor, MyClippingRect, OutDrawElements, GraphObj);
}
else if (Schema->IsA(USoundCueGraphSchema::StaticClass()))
{
ConnectionDrawingPolicy = new FSoundCueGraphConnectionDrawingPolicy(WireLayerId, MaxLayerId, ZoomFactor, MyClippingRect, OutDrawElements, GraphObj);
}
else if (Schema->IsA(UMaterialGraphSchema::StaticClass()))
{
ConnectionDrawingPolicy = new FMaterialGraphConnectionDrawingPolicy(WireLayerId, MaxLayerId, ZoomFactor, MyClippingRect, OutDrawElements, GraphObj);
}
else
{
ConnectionDrawingPolicy = new FConnectionDrawingPolicy(WireLayerId, MaxLayerId, ZoomFactor, MyClippingRect, OutDrawElements);
}
}
}
TArray<TSharedPtr<SGraphPin>> OverridePins;
for (const FGraphPinHandle& Handle : PreviewConnectorFromPins)
{
TSharedPtr<SGraphPin> Pin = Handle.FindInGraphPanel(*this);
if (Pin.IsValid())
{
OverridePins.Add(Pin);
}
}
ConnectionDrawingPolicy->SetHoveredPins(CurrentHoveredPins, OverridePins, TimeSinceMouseEnteredPin);
ConnectionDrawingPolicy->SetMarkedPin(MarkedPin);
// Get the set of pins for all children and synthesize geometry for culled out pins so lines can be drawn to them.
TMap<TSharedRef<SWidget>, FArrangedWidget> PinGeometries;
TSet< TSharedRef<SWidget> > VisiblePins;
for (int32 ChildIndex = 0; ChildIndex < Children.Num(); ++ChildIndex)
{
TSharedRef<SGraphNode> ChildNode = StaticCastSharedRef<SGraphNode>(Children[ChildIndex]);
// If this is a culled node, approximate the pin geometry to the corner of the node it is within
if (IsNodeCulled(ChildNode, AllottedGeometry))
{
TArray< TSharedRef<SWidget> > NodePins;
ChildNode->GetPins(NodePins);
const FVector2D NodeLoc = ChildNode->GetPosition();
const FGeometry SynthesizedNodeGeometry(GraphCoordToPanelCoord(NodeLoc), AllottedGeometry.AbsolutePosition, FVector2D::ZeroVector, 1.f);
for (TArray< TSharedRef<SWidget> >::TConstIterator NodePinIterator(NodePins); NodePinIterator; ++NodePinIterator)
{
const SGraphPin& PinWidget = static_cast<const SGraphPin&>((*NodePinIterator).Get());
FVector2D PinLoc = NodeLoc + PinWidget.GetNodeOffset();
const FGeometry SynthesizedPinGeometry(GraphCoordToPanelCoord(PinLoc), AllottedGeometry.AbsolutePosition, FVector2D::ZeroVector, 1.f);
PinGeometries.Add(*NodePinIterator, FArrangedWidget(*NodePinIterator, SynthesizedPinGeometry));
}
// Also add synthesized geometries for culled nodes
ArrangedChildren.AddWidget( FArrangedWidget(ChildNode, SynthesizedNodeGeometry) );
}
else
{
ChildNode->GetPins(VisiblePins);
}
}
// Now get the pin geometry for all visible children and append it to the PinGeometries map
TMap<TSharedRef<SWidget>, FArrangedWidget> VisiblePinGeometries;
{
this->FindChildGeometries(AllottedGeometry, VisiblePins, VisiblePinGeometries);
PinGeometries.Append(VisiblePinGeometries);
}
// Draw preview connections (only connected on one end)
if (PreviewConnectorFromPins.Num() > 0)
{
for (const FGraphPinHandle& Handle : PreviewConnectorFromPins)
{
TSharedPtr< SGraphPin > CurrentStartPin = Handle.FindInGraphPanel(*this);
if (!CurrentStartPin.IsValid())
{
continue;
}
const FArrangedWidget* PinGeometry = PinGeometries.Find( CurrentStartPin.ToSharedRef() );
if (PinGeometry != NULL)
{
FVector2D StartPoint;
FVector2D EndPoint;
if (CurrentStartPin->GetDirection() == EGPD_Input)
{
StartPoint = AllottedGeometry.AbsolutePosition + PreviewConnectorEndpoint;
EndPoint = FGeometryHelper::VerticalMiddleLeftOf( PinGeometry->Geometry ) - FVector2D(ConnectionDrawingPolicy->ArrowRadius.X, 0);
}
else
{
StartPoint = FGeometryHelper::VerticalMiddleRightOf( PinGeometry->Geometry );
EndPoint = AllottedGeometry.AbsolutePosition + PreviewConnectorEndpoint;
}
ConnectionDrawingPolicy->DrawPreviewConnector(PinGeometry->Geometry, StartPoint, EndPoint, CurrentStartPin.Get()->GetPinObj());
}
//@TODO: Re-evaluate this incompatible mojo; it's mutating every pin state every frame to accomplish a visual effect
ConnectionDrawingPolicy->SetIncompatiblePinDrawState(CurrentStartPin, VisiblePins);
}
}
else
{
//@TODO: Re-evaluate this incompatible mojo; it's mutating every pin state every frame to accomplish a visual effect
ConnectionDrawingPolicy->ResetIncompatiblePinDrawState(VisiblePins);
}
// Draw all regular connections
ConnectionDrawingPolicy->Draw(PinGeometries, ArrangedChildren);
delete ConnectionDrawingPolicy;
}
// Draw a shadow overlay around the edges of the graph
++MaxLayerId;
PaintSurroundSunkenShadow(FEditorStyle::GetBrush(TEXT("Graph.Shadow")), AllottedGeometry, MyClippingRect, OutDrawElements, MaxLayerId);
if(ShowGraphStateOverlay.Get())
{
const FSlateBrush* BorderBrush = nullptr;
if((GEditor->bIsSimulatingInEditor || GEditor->PlayWorld != NULL))
{
// Draw a surrounding indicator when PIE is active, to make it clear that the graph is read-only, etc...
BorderBrush = FEditorStyle::GetBrush(TEXT("Graph.PlayInEditor"));
}
else if(!IsEditable.Get())
{
// Draw a different border when we're not simulating but the graph is read-only
BorderBrush = FEditorStyle::GetBrush(TEXT("Graph.ReadOnlyBorder"));
}
if(BorderBrush)
{
// Actually draw the border
FSlateDrawElement::MakeBox(
OutDrawElements,
MaxLayerId,
AllottedGeometry.ToPaintGeometry(),
BorderBrush,
MyClippingRect
);
}
}
// Draw the marquee selection rectangle
PaintMarquee(AllottedGeometry, MyClippingRect, OutDrawElements, MaxLayerId);
// Draw the software cursor
++MaxLayerId;
PaintSoftwareCursor(AllottedGeometry, MyClippingRect, OutDrawElements, MaxLayerId);
return MaxLayerId;
}
FWeakWidgetPath::EPathResolutionResult::Result FWeakWidgetPath::ToWidgetPath( FWidgetPath& WidgetPath, EInterruptedPathHandling::Type InterruptedPathHandling, const FPointerEvent* PointerEvent ) const
{
SCOPE_CYCLE_COUNTER(STAT_ToWidgetPath);
TArray<FWidgetAndPointer> PathWithGeometries;
TArray< TSharedPtr<SWidget> > WidgetPtrs;
// Convert the weak pointers into shared pointers because we are about to do something with this path instead of just observe it.
TSharedPtr<SWindow> TopLevelWindowPtr = Window.Pin();
for( TArray< TWeakPtr<SWidget> >::TConstIterator SomeWeakWidgetPtr( Widgets ); SomeWeakWidgetPtr; ++SomeWeakWidgetPtr )
{
WidgetPtrs.Add( SomeWeakWidgetPtr->Pin() );
}
// The path can get interrupted if some subtree of widgets disappeared, but we still maintain weak references to it.
bool bPathUninterrupted = false;
// For each widget in the path compute the geometry. We are able to do this starting with the top-level window because it knows its own geometry.
if ( TopLevelWindowPtr.IsValid() )
{
bPathUninterrupted = true;
FGeometry ParentGeometry = TopLevelWindowPtr->GetWindowGeometryInScreen();
PathWithGeometries.Add( FWidgetAndPointer(
FArrangedWidget( TopLevelWindowPtr.ToSharedRef(), ParentGeometry ),
// @todo slate: this should be the cursor's virtual position in window space.
TSharedPtr<FVirtualPointerPosition>() ) );
FArrangedChildren ArrangedChildren(EVisibility::Visible, true);
TSharedPtr<FVirtualPointerPosition> VirtualPointerPos;
// For every widget in the vertical slice...
for( int32 WidgetIndex = 0; bPathUninterrupted && WidgetIndex < WidgetPtrs.Num()-1; ++WidgetIndex )
{
TSharedPtr<SWidget> CurWidget = WidgetPtrs[WidgetIndex];
bool bFoundChild = false;
if ( CurWidget.IsValid() )
{
// Arrange the widget's children to find their geometries.
ArrangedChildren.Empty();
CurWidget->ArrangeChildren(ParentGeometry, ArrangedChildren);
// Find the next widget in the path among the arranged children.
for( int32 SearchIndex = 0; !bFoundChild && SearchIndex < ArrangedChildren.Num(); ++SearchIndex )
{
FArrangedWidget& ArrangedWidget = ArrangedChildren[SearchIndex];
if ( ArrangedWidget.Widget == WidgetPtrs[WidgetIndex+1] )
{
if( PointerEvent && !VirtualPointerPos.IsValid() )
{
VirtualPointerPos = CurWidget->TranslateMouseCoordinateFor3DChild( ArrangedWidget.Widget, ParentGeometry, PointerEvent->GetScreenSpacePosition(), PointerEvent->GetLastScreenSpacePosition() );
}
bFoundChild = true;
// Remember the widget, the associated geometry, and the pointer position in a transformed space.
PathWithGeometries.Add( FWidgetAndPointer(ArrangedChildren[SearchIndex], VirtualPointerPos) );
// The next child in the vertical slice will be arranged with respect to its parent's geometry.
ParentGeometry = ArrangedChildren[SearchIndex].Geometry;
}
}
}
bPathUninterrupted = bFoundChild;
if (!bFoundChild && InterruptedPathHandling == EInterruptedPathHandling::ReturnInvalid )
{
return EPathResolutionResult::Truncated;
}
}
}
WidgetPath = FWidgetPath( PathWithGeometries );
return bPathUninterrupted ? EPathResolutionResult::Live : EPathResolutionResult::Truncated;
}
/**
* Move focus either forward on backward in the path level specified by PathLevel.
* That is, this movement of focus will modify the subtree under Widgets(PathLevel).
*
* @param PathLevel The level in this WidgetPath whose focus to move.
* @param MoveDirectin Move focus forward or backward?
*
* @return true if the focus moved successfully, false if we were unable to move focus
*/
bool FWidgetPath::MoveFocus(int32 PathLevel, EUINavigation NavigationType)
{
check(NavigationType == EUINavigation::Next || NavigationType == EUINavigation::Previous);
const int32 MoveDirectionAsInt = (NavigationType == EUINavigation::Next)
? +1
: -1;
if ( PathLevel == Widgets.Num()-1 )
{
// We are the currently focused widget because we are at the very bottom of focus path.
if (NavigationType == EUINavigation::Next)
{
// EFocusMoveDirection::Next implies descend, so try to find a focusable descendant.
return ExtendPathTo( FFocusableWidgetMatcher() );
}
else
{
// EFocusMoveDirection::Previous implies move focus up a level.
return false;
}
}
else if ( Widgets.Num() > 1 )
{
// We are not the last widget in the path.
// GOAL: Look for a focusable descendant to the left or right of the currently focused path.
// Arrange the children so we can iterate through them regardless of widget type.
FArrangedChildren ArrangedChildren(EVisibility::Visible);
Widgets[PathLevel].Widget->ArrangeChildren( Widgets[PathLevel].Geometry, ArrangedChildren );
// Find the currently focused child among the children.
int32 FocusedChildIndex = ArrangedChildren.FindItemIndex( Widgets[PathLevel+1] );
FocusedChildIndex = (FocusedChildIndex) % ArrangedChildren.Num() + MoveDirectionAsInt;
// Now actually search for the widget.
for( ; FocusedChildIndex < ArrangedChildren.Num() && FocusedChildIndex >= 0; FocusedChildIndex += MoveDirectionAsInt )
{
// Neither disabled widgets nor their children can be focused.
if ( ArrangedChildren[FocusedChildIndex].Widget->IsEnabled() )
{
// Look for a focusable descendant.
FArrangedChildren PathToFocusableChild = GeneratePathToWidget(FFocusableWidgetMatcher(), ArrangedChildren[FocusedChildIndex], NavigationType);
// Either we found a focusable descendant, or an immediate child that is focusable.
const bool bFoundNextFocusable = ( PathToFocusableChild.Num() > 0 ) || ArrangedChildren[FocusedChildIndex].Widget->SupportsKeyboardFocus();
if ( bFoundNextFocusable )
{
// We found the next focusable widget, so make this path point at the new widget by:
// First, truncating the FocusPath up to the current level (i.e. PathLevel).
Widgets.Remove( PathLevel+1, Widgets.Num()-PathLevel-1 );
// Second, add the immediate child that is focus or whose descendant is focused.
Widgets.AddWidget( ArrangedChildren[FocusedChildIndex] );
// Add path to focused descendants if any.
Widgets.Append( PathToFocusableChild );
// We successfully moved focus!
return true;
}
}
}
}
return false;
}
/** SWidget interface */
virtual int32 OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const override
{
// First paint the background
{
LayerId = PaintBackground(AllottedGeometry, MyClippingRect, OutDrawElements, LayerId);
LayerId++;
}
FArrangedChildren ArrangedChildren(EVisibility::Visible);
ArrangeChildren(AllottedGeometry, ArrangedChildren);
// Draw the child nodes
// When drawing a marquee, need a preview of what the selection will be.
const auto* SelectionToVisualize = &(SelectionManager.SelectedNodes);
FGraphPanelSelectionSet SelectionPreview;
if (Marquee.IsValid())
{
ApplyMarqueeSelection(Marquee, SelectionManager.SelectedNodes, SelectionPreview);
SelectionToVisualize = &SelectionPreview;
}
int32 NodesLayerId = LayerId;
for (int32 ChildIndex = 0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
FArrangedWidget& CurWidget = ArrangedChildren[ChildIndex];
TSharedRef<SWorldTileItem> ChildNode = StaticCastSharedRef<SWorldTileItem>(CurWidget.Widget);
ChildNode->bAffectedByMarquee = SelectionToVisualize->Contains(ChildNode->GetObjectBeingDisplayed());
LayerId = CurWidget.Widget->Paint(Args.WithNewParent(this), CurWidget.Geometry, MyClippingRect, OutDrawElements, NodesLayerId, InWidgetStyle, ShouldBeEnabled(bParentEnabled));
ChildNode->bAffectedByMarquee = false;
}
// Draw editable world bounds
if (!WorldModel->IsSimulating())
{
float ScreenSpaceSize = FLevelCollectionModel::EditableAxisLength()*GetZoomAmount()*2.f;
FVector2D PaintSize = FVector2D(ScreenSpaceSize, ScreenSpaceSize);
FVector2D PaintPosition = GraphCoordToPanelCoord(FVector2D::ZeroVector) - (PaintSize*0.5f);
float Scale = 0.2f; // Scale down drawing border
FSlateLayoutTransform LayoutTransform(Scale, AllottedGeometry.GetAccumulatedLayoutTransform().GetTranslation() + PaintPosition);
FSlateRenderTransform RenderTransform(Scale, AllottedGeometry.GetAccumulatedRenderTransform().GetTranslation() + PaintPosition);
FPaintGeometry EditableArea(LayoutTransform, RenderTransform, PaintSize/Scale);
FLinearColor PaintColor = FLinearColor::Yellow;
PaintColor.A = 0.4f;
FSlateDrawElement::MakeBox(
OutDrawElements,
++LayerId,
EditableArea,
FEditorStyle::GetBrush(TEXT("Graph.CompactNode.ShadowSelected")),
MyClippingRect,
ESlateDrawEffect::None,
PaintColor
);
}
// Draw the marquee selection rectangle
PaintMarquee(AllottedGeometry, MyClippingRect, OutDrawElements, ++LayerId);
// Draw the software cursor
PaintSoftwareCursor(AllottedGeometry, MyClippingRect, OutDrawElements, ++LayerId);
if(WorldModel->IsSimulating())
{
// Draw a surrounding indicator when PIE is active, to make it clear that the graph is read-only, etc...
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(),
FEditorStyle::GetBrush(TEXT("Graph.PlayInEditor")),
MyClippingRect
);
}
// Draw observer location
{
FVector ObserverPosition;
FRotator ObserverRotation;
if (WorldModel->GetObserverView(ObserverPosition, ObserverRotation))
{
FVector2D ObserverPositionScreen = GraphCoordToPanelCoord(FVector2D(ObserverPosition.X, ObserverPosition.Y));
const FSlateBrush* CameraImage = FEditorStyle::GetBrush(TEXT("WorldBrowser.SimulationViewPositon"));
FPaintGeometry PaintGeometry = AllottedGeometry.ToPaintGeometry(
ObserverPositionScreen - CameraImage->ImageSize*0.5f,
CameraImage->ImageSize
);
FSlateDrawElement::MakeRotatedBox(
OutDrawElements,
++LayerId,
PaintGeometry,
CameraImage,
MyClippingRect,
ESlateDrawEffect::None,
FMath::DegreesToRadians(ObserverRotation.Yaw),
CameraImage->ImageSize*0.5f,
FSlateDrawElement::RelativeToElement
);
}
FVector PlayerPosition;
FRotator PlayerRotation;
if (WorldModel->GetPlayerView(PlayerPosition, PlayerRotation))
{
FVector2D PlayerPositionScreen = GraphCoordToPanelCoord(FVector2D(PlayerPosition.X, PlayerPosition.Y));
const FSlateBrush* CameraImage = FEditorStyle::GetBrush(TEXT("WorldBrowser.SimulationViewPositon"));
FPaintGeometry PaintGeometry = AllottedGeometry.ToPaintGeometry(
PlayerPositionScreen - CameraImage->ImageSize*0.5f,
CameraImage->ImageSize
);
FSlateDrawElement::MakeRotatedBox(
OutDrawElements,
++LayerId,
PaintGeometry,
CameraImage,
MyClippingRect,
ESlateDrawEffect::None,
FMath::DegreesToRadians(PlayerRotation.Yaw),
CameraImage->ImageSize*0.5f,
FSlateDrawElement::RelativeToElement,
FLinearColor(FColorList::Orange)
);
}
}
LayerId = PaintScaleRuler(AllottedGeometry, MyClippingRect, OutDrawElements, LayerId);
return LayerId;
}
