void SSequencerTrackArea::OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const
{
for (int32 ChildIndex = 0; ChildIndex < Children.Num(); ++ChildIndex)
{
const FTrackAreaSlot& CurChild = Children[ChildIndex];
const EVisibility ChildVisibility = CurChild.GetWidget()->GetVisibility();
if (!ArrangedChildren.Accepts(ChildVisibility))
{
continue;
}
const FMargin Padding(0, CurChild.GetVerticalOffset(), 0, 0);
AlignmentArrangeResult XResult = AlignChild<Orient_Horizontal>(AllottedGeometry.Size.X, CurChild, Padding, 1.0f, false);
AlignmentArrangeResult YResult = AlignChild<Orient_Vertical>(AllottedGeometry.Size.Y, CurChild, Padding, 1.0f, false);
ArrangedChildren.AddWidget(ChildVisibility,
AllottedGeometry.MakeChild(
CurChild.GetWidget(),
FVector2D(XResult.Offset,YResult.Offset),
FVector2D(XResult.Size, YResult.Size)
)
);
}
}
void SAnimationOutlinerView::OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const
{
const float Padding = SequencerLayoutConstants::NodePadding;
const float IndentAmount = SequencerLayoutConstants::IndentAmount;
float CurrentHeight = 0;
for (int32 WidgetIndex = 0; WidgetIndex < Children.Num(); ++WidgetIndex)
{
const TSharedRef<SAnimationOutlinerTreeNode>& Widget = Children[WidgetIndex];
EVisibility Visibility = Widget->GetVisibility();
if( ArrangedChildren.Accepts( Visibility ) )
{
const TSharedPtr<const FSequencerDisplayNode>& DisplayNode = Widget->GetDisplayNode();
// How large to make this node
float HeightIncrement = DisplayNode->GetNodeHeight();
// How far to indent the widget
float WidgetIndentOffset = IndentAmount*DisplayNode->GetTreeLevel();
// Place the widget at the current height, at the nodes desired size
ArrangedChildren.AddWidget(
Visibility,
AllottedGeometry.MakeChild( Widget, FVector2D( WidgetIndentOffset, CurrentHeight ), FVector2D( AllottedGeometry.GetDrawSize().X-WidgetIndentOffset, HeightIncrement ) )
);
// Compute the start height for the next widget
CurrentHeight += HeightIncrement+Padding;
}
}
}
void SUniformGridPanel::OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const
{
if ( Children.Num() > 0 )
{
const FVector2D CellSize(AllottedGeometry.Size.X / NumColumns, AllottedGeometry.Size.Y / NumRows);
const FMargin& CurrentSlotPadding(SlotPadding.Get());
for ( int32 ChildIndex=0; ChildIndex < Children.Num(); ++ChildIndex )
{
const FSlot& Child = Children[ChildIndex];
const EVisibility ChildVisibility = Child.GetWidget()->GetVisibility();
if ( ArrangedChildren.Accepts(ChildVisibility) )
{
// Do the standard arrangement of elements within a slot
// Takes care of alignment and padding.
AlignmentArrangeResult XAxisResult = AlignChild<Orient_Horizontal>(CellSize.X, Child, CurrentSlotPadding);
AlignmentArrangeResult YAxisResult = AlignChild<Orient_Vertical>(CellSize.Y, Child, CurrentSlotPadding);
ArrangedChildren.AddWidget(ChildVisibility,
AllottedGeometry.MakeChild(Child.GetWidget(),
FVector2D(CellSize.X*Child.Column + XAxisResult.Offset, CellSize.Y*Child.Row + YAxisResult.Offset),
FVector2D(XAxisResult.Size, YAxisResult.Size)
));
}
}
}
}
void SScaleBox::OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const
{
const EVisibility ChildVisibility = ChildSlot.GetWidget()->GetVisibility();
if ( ArrangedChildren.Accepts(ChildVisibility) )
{
FVector2D DesiredSize = ChildSlot.GetWidget()->GetDesiredSize();
float FinalScale = 1;
EStretch::Type CurrentStretch = Stretch.Get();
EStretchDirection::Type CurrentStretchDirection = StretchDirection.Get();
if ( DesiredSize.X != 0 && DesiredSize.Y != 0 )
{
switch ( CurrentStretch )
{
case EStretch::None:
break;
case EStretch::Fill:
DesiredSize = AllottedGeometry.Size;
break;
case EStretch::ScaleToFit:
FinalScale = FMath::Min(AllottedGeometry.Size.X / DesiredSize.X, AllottedGeometry.Size.Y / DesiredSize.Y);
break;
case EStretch::ScaleToFill:
FinalScale = FMath::Max(AllottedGeometry.Size.X / DesiredSize.X, AllottedGeometry.Size.Y / DesiredSize.Y);
break;
}
switch ( CurrentStretchDirection )
{
case EStretchDirection::DownOnly:
FinalScale = FMath::Min(FinalScale, 1.0f);
break;
case EStretchDirection::UpOnly:
FinalScale = FMath::Max(FinalScale, 1.0f);
break;
}
}
FVector2D FinalOffset(0, 0);
if ( CurrentStretch != EStretch::Fill )
{
const FMargin SlotPadding(ChildSlot.SlotPadding.Get());
AlignmentArrangeResult XResult = AlignChild<Orient_Horizontal>(AllottedGeometry.Size.X, ChildSlot, SlotPadding, FinalScale, false);
AlignmentArrangeResult YResult = AlignChild<Orient_Vertical>(AllottedGeometry.Size.Y, ChildSlot, SlotPadding, FinalScale, false);
FinalOffset = FVector2D(XResult.Offset, YResult.Offset) * ( 1.0f / FinalScale );
}
ArrangedChildren.AddWidget(ChildVisibility, AllottedGeometry.MakeChild(
ChildSlot.GetWidget(),
FinalOffset,
DesiredSize,
FinalScale
) );
}
}
void SWeakWidget::OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const
{
// We just want to show the child that we are presenting. Always stretch it to occupy all of the space.
TSharedRef<SWidget> MyContent = WeakChild.GetWidget();
if( MyContent!=SNullWidget::NullWidget && ArrangedChildren.Accepts(MyContent->GetVisibility()) )
{
ArrangedChildren.AddWidget( AllottedGeometry.MakeChild(
MyContent,
FVector2D(0,0),
AllottedGeometry.Size
) );
}
}
void SFxWidget::OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const
{
const EVisibility MyVisibility = this->GetVisibility();
if ( ArrangedChildren.Accepts( MyVisibility ) )
{
// Only layout scale affects the arranged geometry.
const FSlateLayoutTransform LayoutTransform(LayoutScale.Get());
ArrangedChildren.AddWidget( AllottedGeometry.MakeChild(
this->ChildSlot.GetWidget(),
TransformVector(Inverse(LayoutTransform), AllottedGeometry.Size),
LayoutTransform));
}
}
void SDPIScaler::OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const
{
const EVisibility MyVisibility = this->GetVisibility();
if ( ArrangedChildren.Accepts( MyVisibility ) )
{
const float MyDPIScale = DPIScale.Get();
ArrangedChildren.AddWidget( AllottedGeometry.MakeChild(
this->ChildSlot.GetWidget(),
FVector2D::ZeroVector,
AllottedGeometry.Size / MyDPIScale,
MyDPIScale
));
}
}
void SZoomPan::OnArrangeChildren(const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren) const
{
const EVisibility ChildVisibility = ChildSlot.GetWidget()->GetVisibility();
if ( ArrangedChildren.Accepts(ChildVisibility) )
{
const FMargin SlotPadding(ChildSlot.SlotPadding.Get());
AlignmentArrangeResult XResult = AlignChild<Orient_Horizontal>(AllottedGeometry.Size.X, ChildSlot, SlotPadding, 1);
AlignmentArrangeResult YResult = AlignChild<Orient_Vertical>(AllottedGeometry.Size.Y, ChildSlot, SlotPadding, 1);
ArrangedChildren.AddWidget( ChildVisibility, AllottedGeometry.MakeChild(
ChildSlot.GetWidget(),
FVector2D(XResult.Offset, YResult.Offset) - ViewOffset.Get(),
ChildSlot.GetWidget()->GetDesiredSize(),
ZoomAmount.Get()
) );
}
}
void SBox::OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const
{
const EVisibility& MyCurrentVisibility = this->GetVisibility();
if ( ArrangedChildren.Accepts( MyCurrentVisibility ) )
{
const FMargin SlotPadding(ChildSlot.SlotPadding.Get());
AlignmentArrangeResult XAlignmentResult = AlignChild<Orient_Horizontal>( AllottedGeometry.Size.X, ChildSlot, SlotPadding );
AlignmentArrangeResult YAlignmentResult = AlignChild<Orient_Vertical>( AllottedGeometry.Size.Y, ChildSlot, SlotPadding );
ArrangedChildren.AddWidget(
AllottedGeometry.MakeChild(
ChildSlot.GetWidget(),
FVector2D(XAlignmentResult.Offset, YAlignmentResult.Offset),
FVector2D(XAlignmentResult.Size, YAlignmentResult.Size)
)
);
}
}
/** SWidget interface */
virtual void OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const override
{
for (int32 ChildIndex=0; ChildIndex < VisibleChildren.Num(); ++ChildIndex)
{
const auto Child = StaticCastSharedRef<SWorldTileItem>(VisibleChildren[ChildIndex]);
const EVisibility ChildVisibility = Child->GetVisibility();
if (ArrangedChildren.Accepts(ChildVisibility))
{
FVector2D ChildPos = Child->GetPosition();
ArrangedChildren.AddWidget(ChildVisibility,
AllottedGeometry.MakeChild(Child,
ChildPos - GetViewOffset(),
Child->GetDesiredSize(), GetZoomAmount()
));
}
}
}
void SSequencerSectionAreaView::OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const
{
int32 MaxRowIndex = 0;
for( int32 WidgetIndex = 0; WidgetIndex < Children.Num(); ++WidgetIndex )
{
const TSharedRef<SSection>& Widget = Children[WidgetIndex];
TSharedPtr<ISequencerSection> SectionInterface = Widget->GetSectionInterface();
MaxRowIndex = FMath::Max(MaxRowIndex, SectionInterface->GetSectionObject()->GetRowIndex());
}
int32 MaxTracks = MaxRowIndex + 1;
float SectionHeight = GetSectionAreaHeight();
FTimeToPixel TimeToPixelConverter = GetTimeToPixel( AllottedGeometry );
for( int32 WidgetIndex = 0; WidgetIndex < Children.Num(); ++WidgetIndex )
{
const TSharedRef<SSection>& Widget = Children[WidgetIndex];
TSharedPtr<ISequencerSection> SectionInterface = Widget->GetSectionInterface();
int32 RowIndex = SectionInterface->GetSectionObject()->GetRowIndex();
FGeometry SectionGeometry = SequencerSectionUtils::GetSectionGeometry( AllottedGeometry, RowIndex, MaxTracks, SectionHeight, SectionInterface, TimeToPixelConverter );
EVisibility Visibility = Widget->GetVisibility();
if( ArrangedChildren.Accepts( Visibility ) )
{
Widget->CacheParentGeometry(AllottedGeometry);
ArrangedChildren.AddWidget(
Visibility,
AllottedGeometry.MakeChild( Widget, SectionGeometry.Position, SectionGeometry.GetDrawSize() )
);
}
}
}
void SGridPanel::ArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const
{
// PREPARE PHASE
// Prepare some data for arranging children.
// FinalColumns will be populated with column sizes that include the stretched column sizes.
// Then we will build partial sums so that we can easily handle column spans.
// Repeat the same for rows.
float ColumnCoeffTotal = 0.0f;
TArray<float> FinalColumns;
if ( Columns.Num() > 0 )
{
FinalColumns.AddUninitialized(Columns.Num());
FinalColumns[FinalColumns.Num()-1] = 0.0f;
}
float RowCoeffTotal = 0.0f;
TArray<float> FinalRows;
if ( Rows.Num() > 0 )
{
FinalRows.AddUninitialized(Rows.Num());
FinalRows[FinalRows.Num()-1] = 0.0f;
}
FVector2D FlexSpace = AllottedGeometry.Size;
const int32 ColFillCoeffsLength = ColFillCoefficients.Num();
for(int32 ColIndex=0; ColIndex < Columns.Num(); ++ColIndex)
{
// Compute the total space available for stretchy columns.
if (ColIndex >= ColFillCoeffsLength || ColFillCoefficients[ColIndex] == 0)
{
FlexSpace.X -= Columns[ColIndex];
}
else //(ColIndex < ColFillCoeffsLength)
{
// Compute the denominator for dividing up the stretchy column space
ColumnCoeffTotal += ColFillCoefficients[ColIndex];
}
}
for(int32 ColIndex=0; ColIndex < Columns.Num(); ++ColIndex)
{
// Figure out how big each column needs to be
FinalColumns[ColIndex] = (ColIndex < ColFillCoeffsLength && ColFillCoefficients[ColIndex] != 0)
? (ColFillCoefficients[ColIndex] / ColumnCoeffTotal * FlexSpace.X)
: Columns[ColIndex];
}
const int32 RowFillCoeffsLength = RowFillCoefficients.Num();
for(int32 RowIndex=0; RowIndex < Rows.Num(); ++RowIndex)
{
// Compute the total space available for stretchy rows.
if (RowIndex >= RowFillCoeffsLength || RowFillCoefficients[RowIndex] == 0)
{
FlexSpace.Y -= Rows[RowIndex];
}
else //(RowIndex < RowFillCoeffsLength)
{
// Compute the denominator for dividing up the stretchy row space
RowCoeffTotal += RowFillCoefficients[RowIndex];
}
}
for(int32 RowIndex=0; RowIndex < Rows.Num(); ++RowIndex)
{
// Compute how big each row needs to be
FinalRows[RowIndex] = (RowIndex < RowFillCoeffsLength && RowFillCoefficients[RowIndex] != 0)
? (RowFillCoefficients[RowIndex] / RowCoeffTotal * FlexSpace.Y)
: Rows[RowIndex];
}
// Build up partial sums for row and column sizes so that we can handle column and row spans conveniently.
ComputePartialSums(FinalColumns);
ComputePartialSums(FinalRows);
// ARRANGE PHASE
for( int32 SlotIndex=0; SlotIndex < Slots.Num(); ++SlotIndex )
{
const FSlot& CurSlot = Slots[SlotIndex];
const EVisibility ChildVisibility = CurSlot.Widget->GetVisibility();
if ( ArrangedChildren.Accepts(ChildVisibility) )
{
// Figure out the position of this cell.
const FVector2D ThisCellOffset( FinalColumns[CurSlot.ColumnParam], FinalRows[CurSlot.RowParam] );
// Figure out the size of this slot; takes row span into account.
// We use the properties of partial sums arrays to achieve this.
const FVector2D CellSize(
FinalColumns[CurSlot.ColumnParam+CurSlot.ColumnSpanParam] - ThisCellOffset.X ,
FinalRows[CurSlot.RowParam+CurSlot.RowSpanParam] - ThisCellOffset.Y );
// Do the standard arrangement of elements within a slot
// Takes care of alignment and padding.
const FMargin SlotPadding(CurSlot.SlotPadding.Get());
AlignmentArrangeResult XAxisResult = AlignChild<Orient_Horizontal>( CellSize.X, CurSlot, SlotPadding );
AlignmentArrangeResult YAxisResult = AlignChild<Orient_Vertical>( CellSize.Y, CurSlot, SlotPadding );
// Output the result
ArrangedChildren.AddWidget( ChildVisibility, AllottedGeometry.MakeChild(
CurSlot.Widget,
ThisCellOffset + FVector2D( XAxisResult.Offset, YAxisResult.Offset ) + CurSlot.NudgeParam,
FVector2D(XAxisResult.Size, YAxisResult.Size)
));
}
}
}
void SGridPanel::OnArrangeChildren( const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren ) const
{
// PREPARE PHASE
// Prepare some data for arranging children.
// FinalColumns will be populated with column sizes that include the stretched column sizes.
// Then we will build partial sums so that we can easily handle column spans.
// Repeat the same for rows.
float ColumnCoeffTotal = 0.0f;
TArray<float> FinalColumns;
if ( Columns.Num() > 0 )
{
FinalColumns.AddUninitialized(Columns.Num());
FinalColumns[FinalColumns.Num()-1] = 0.0f;
}
float RowCoeffTotal = 0.0f;
TArray<float> FinalRows;
if ( Rows.Num() > 0 )
{
FinalRows.AddUninitialized(Rows.Num());
FinalRows[FinalRows.Num()-1] = 0.0f;
}
CalculateStretchedCellSizes(FinalColumns, AllottedGeometry.Size.X, Columns, ColFillCoefficients);
CalculateStretchedCellSizes(FinalRows, AllottedGeometry.Size.Y, Rows, RowFillCoefficients);
// Build up partial sums for row and column sizes so that we can handle column and row spans conveniently.
ComputePartialSums(FinalColumns);
ComputePartialSums(FinalRows);
// ARRANGE PHASE
for( int32 SlotIndex=0; SlotIndex < Slots.Num(); ++SlotIndex )
{
const FSlot& CurSlot = Slots[SlotIndex];
const EVisibility ChildVisibility = CurSlot.GetWidget()->GetVisibility();
if ( ArrangedChildren.Accepts(ChildVisibility) )
{
// Figure out the position of this cell.
const FVector2D ThisCellOffset( FinalColumns[CurSlot.ColumnParam], FinalRows[CurSlot.RowParam] );
// Figure out the size of this slot; takes row span into account.
// We use the properties of partial sums arrays to achieve this.
const FVector2D CellSize(
FinalColumns[CurSlot.ColumnParam+CurSlot.ColumnSpanParam] - ThisCellOffset.X ,
FinalRows[CurSlot.RowParam+CurSlot.RowSpanParam] - ThisCellOffset.Y );
// Do the standard arrangement of elements within a slot
// Takes care of alignment and padding.
const FMargin SlotPadding(CurSlot.SlotPadding.Get());
AlignmentArrangeResult XAxisResult = AlignChild<Orient_Horizontal>( CellSize.X, CurSlot, SlotPadding );
AlignmentArrangeResult YAxisResult = AlignChild<Orient_Vertical>( CellSize.Y, CurSlot, SlotPadding );
// Output the result
ArrangedChildren.AddWidget( ChildVisibility, AllottedGeometry.MakeChild(
CurSlot.GetWidget(),
ThisCellOffset + FVector2D( XAxisResult.Offset, YAxisResult.Offset ) + CurSlot.NudgeParam,
FVector2D(XAxisResult.Size, YAxisResult.Size)
));
}
}
}