int32 SARResourceBarWidget::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
const FSlateBrush* BrushResource = new FSlateBrush();
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(),
BrushResource,
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Gray * 0.35f
);
if (MyAttrComp.IsValid())
{
FVector2D WidgetSize = MyClippingRect.GetSize();
//float HealthWidth = (MyAttrComp->Health * WidgetSize.X) / MyAttrComp->MaxHealth;
float HealthWidth = (CurrentValue.Get() * WidgetSize.X) / MaxValue.Get();
// Draw current health
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(FVector2D::ZeroVector, FVector2D(HealthWidth, WidgetSize.Y)),
BrushResource,
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Red *.9f
);
}
return SCompoundWidget::OnPaint(Args, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
}
void SSection::DrawSectionBorders( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId ) const
{
UMovieSceneSection* SectionObject = SectionInterface->GetSectionObject();
FSequencerSelection& Selection = ParentSectionArea->GetSequencer().GetSelection();
const bool bSelected = Selection.IsSelected(SectionObject);
const bool bActive = Selection.GetActiveSelection() == FSequencerSelection::EActiveSelection::KeyAndSection;
static const FName SelectionColorName("SelectionColor");
static const FName SelectionInactiveColorName("SelectionColorInactive");
FLinearColor SelectionColor = FEditorStyle::GetSlateColor(SelectionColorName).GetColor(FWidgetStyle());
FLinearColor SelectionInactiveColor = FEditorStyle::GetSlateColor(SelectionInactiveColorName).GetColor(FWidgetStyle());
FLinearColor TransparentSelectionColor = SelectionColor;
static const FName SectionGripLeftName("Sequencer.SectionGripLeft");
static const FName SectionGripRightName("Sequencer.SectionGripRight");
// Left Grip
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
// Center the key along Y. Ensure the middle of the key is at the actual key time
AllottedGeometry.ToPaintGeometry( FVector2D( 0.0f, 0.0f ), FVector2D( SequencerSectionConstants::SectionGripSize, AllottedGeometry.GetDrawSize().Y) ) ,
FEditorStyle::GetBrush(SectionGripLeftName),
MyClippingRect,
ESlateDrawEffect::None,
(bLeftEdgePressed || bLeftEdgeHovered) ? TransparentSelectionColor : FLinearColor::White
);
// Right Grip
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
// Center the key along Y. Ensure the middle of the key is at the actual key time
AllottedGeometry.ToPaintGeometry( FVector2D( AllottedGeometry.Size.X-SequencerSectionConstants::SectionGripSize, 0.0f), FVector2D(SequencerSectionConstants::SectionGripSize, AllottedGeometry.GetDrawSize().Y)),
FEditorStyle::GetBrush(SectionGripRightName),
MyClippingRect,
ESlateDrawEffect::None,
(bRightEdgePressed || bRightEdgeHovered) ? TransparentSelectionColor : FLinearColor::White
);
// draw selection box
if(bSelected)
{
static const FName SelectionBorder("Sequencer.Section.SelectionBorder");
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry(),
FEditorStyle::GetBrush(SelectionBorder),
MyClippingRect,
ESlateDrawEffect::None,
bActive ? SelectionColor : SelectionInactiveColor
);
}
}
int32 FSequencerTimeSliderController::DrawPlaybackRange(const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FScrubRangeToScreen& RangeToScreen, const FPaintPlaybackRangeArgs& Args) const
{
if (!TimeSliderArgs.PlaybackRange.IsSet())
{
return LayerId;
}
TRange<float> PlaybackRange = TimeSliderArgs.PlaybackRange.Get();
float PlaybackRangeL = RangeToScreen.InputToLocalX(PlaybackRange.GetLowerBoundValue()) - 1;
float PlaybackRangeR = RangeToScreen.InputToLocalX(PlaybackRange.GetUpperBoundValue()) + 1;
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry(FVector2D(PlaybackRangeL, 0.f), FVector2D(Args.BrushWidth, AllottedGeometry.Size.Y)),
Args.StartBrush,
MyClippingRect,
ESlateDrawEffect::None,
FColor(32, 128, 32) // 120, 75, 50 (HSV)
);
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry(FVector2D(PlaybackRangeR - Args.BrushWidth, 0.f), FVector2D(Args.BrushWidth, AllottedGeometry.Size.Y)),
Args.EndBrush,
MyClippingRect,
ESlateDrawEffect::None,
FColor(128, 32, 32) // 0, 75, 50 (HSV)
);
// Black tint for excluded regions
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry(FVector2D(0.f, 0.f), FVector2D(PlaybackRangeL, AllottedGeometry.Size.Y)),
FEditorStyle::GetBrush("WhiteBrush"),
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Black.CopyWithNewOpacity(0.2f)
);
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry(FVector2D(PlaybackRangeR, 0.f), FVector2D(AllottedGeometry.Size.X - PlaybackRangeR, AllottedGeometry.Size.Y)),
FEditorStyle::GetBrush("WhiteBrush"),
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Black.CopyWithNewOpacity(0.2f)
);
return LayerId + 1;
}
virtual int32 OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const override
{
LayerId = SPanel::OnPaint(Args, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
LayerId = ScrollyZoomy.PaintSoftwareCursorIfNeeded(AllottedGeometry, MyClippingRect, OutDrawElements, LayerId);
TSharedPtr<FWidgetReflectorNodeBase> Window = SnapshotDataPtr->GetWindow(SelectedWindowIndex);
if (Window.IsValid())
{
const FVector2D RootDrawOffset = PhysicalOffset - Window->GetAccumulatedLayoutTransform().GetTranslation();
if (bIsPicking)
{
const FLinearColor TopmostWidgetColor(1.0f, 0.0f, 0.0f);
const FLinearColor LeafmostWidgetColor(0.0f, 1.0f, 0.0f);
for (int32 WidgetIndex = 0; WidgetIndex < PickedWidgets.Num(); ++WidgetIndex)
{
const TSharedRef<FWidgetReflectorNodeBase>& PickedWidget = PickedWidgets[WidgetIndex];
const float ColorFactor = static_cast<float>(WidgetIndex)/PickedWidgets.Num();
const FLinearColor Tint(1.0f - ColorFactor, ColorFactor, 0.0f, 1.0f);
FSlateDrawElement::MakeBox(
OutDrawElements,
++LayerId,
AllottedGeometry.ToPaintGeometry(RootDrawOffset + PickedWidget->GetAccumulatedLayoutTransform().GetTranslation(), TransformPoint(PickedWidget->GetAccumulatedLayoutTransform().GetScale(), PickedWidget->GetLocalSize())),
FCoreStyle::Get().GetBrush(TEXT("Debug.Border")),
MyClippingRect,
ESlateDrawEffect::None,
FMath::Lerp(TopmostWidgetColor, LeafmostWidgetColor, ColorFactor)
);
}
}
else
{
for (const auto& SelectedWidget : SelectedWidgets)
{
FSlateDrawElement::MakeBox(
OutDrawElements,
++LayerId,
AllottedGeometry.ToPaintGeometry(RootDrawOffset + SelectedWidget->GetAccumulatedLayoutTransform().GetTranslation(), TransformPoint(SelectedWidget->GetAccumulatedLayoutTransform().GetScale(), SelectedWidget->GetLocalSize())),
FCoreStyle::Get().GetBrush(TEXT("Debug.Border")),
MyClippingRect,
ESlateDrawEffect::None,
SelectedWidget->GetTint()
);
}
}
}
return LayerId;
}
int32 SBar::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
// Initialize our brush here
const FSlateBrush* BrushResource = new FSlateBrush();
// Draw background box
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(),
BrushResource,
ESlateDrawEffect::None,
FLinearColor::Gray * 0.35f
);
// Calculate Current / Max ratio and turn it into screen width
FVector2D WidgetSize = AllottedGeometry.Size;
float HealthWidth = (Current * WidgetSize.X) / Max;
// Draw current health
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(FVector2D::ZeroVector, FVector2D(HealthWidth, WidgetSize.Y)),
BrushResource,
ESlateDrawEffect::None,
Color
);
// Draw text on health bar
FSlateFontInfo MyFont(FPaths::EngineContentDir() / TEXT("Slate/Fonts/Roboto-Regular.ttf"), 15);
const FText TextNew = FText::FromString(FString::Printf(TEXT("%s: %.0f / %.0f"), Text.ToString().GetCharArray().GetData(), Current, Max));
const TSharedRef< FSlateFontMeasure > FontMeasureService = FSlateApplication::Get().GetRenderer()->GetFontMeasureService();
FVector2D DrawSize = FontMeasureService->Measure(TextNew, MyFont);
FVector2D Pos = WidgetSize / 2.0f - DrawSize / 2.0f;
FSlateDrawElement::MakeText(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(Pos, DrawSize),
TextNew,
MyFont,
ESlateDrawEffect::None,
FLinearColor::White
);
return SCompoundWidget::OnPaint(Args, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
}
int32 SGraphBar::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
// Used to track the layer ID we will return.
int32 RetLayerId = LayerId;
bool bEnabled = ShouldBeEnabled( bParentEnabled );
const ESlateDrawEffect::Type DrawEffects = bEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
const FLinearColor ColorAndOpacitySRGB = InWidgetStyle.GetColorAndOpacityTint();
static const FLinearColor SelectedBarColor(FLinearColor::White);
// Paint inside the border only.
const FVector2D BorderPadding = FTaskGraphStyle::Get()->GetVector("TaskGraph.ProgressBar.BorderPadding");
const FSlateRect ForegroundClippingRect = AllottedGeometry.GetClippingRect().InsetBy(FMargin(BorderPadding.X, BorderPadding.Y)).IntersectionWith(MyClippingRect);
FSlateDrawElement::MakeBox(
OutDrawElements,
RetLayerId++,
AllottedGeometry.ToPaintGeometry(),
BackgroundImage,
MyClippingRect,
DrawEffects,
ColorAndOpacitySRGB
);
// Draw all bars
for( int32 EventIndex = 0; EventIndex < Events.Num(); ++EventIndex )
{
TSharedPtr< FVisualizerEvent > Event = Events[ EventIndex ];
float StartX, EndX;
if( CalculateEventGeometry( Event.Get(), AllottedGeometry, StartX, EndX ) )
{
// Draw Event bar
FSlateDrawElement::MakeBox(
OutDrawElements,
RetLayerId++,
AllottedGeometry.ToPaintGeometry(
FVector2D( StartX, 0.0f ),
FVector2D( EndX - StartX, AllottedGeometry.Size.Y )),
Event->IsSelected ? SelectedImage : FillImage,
ForegroundClippingRect,
DrawEffects,
Event->IsSelected ? SelectedBarColor : ColorPalette[Event->ColorIndex % (sizeof(ColorPalette) / sizeof(ColorPalette[0]))]
);
}
}
return RetLayerId - 1;
}
int32 SCircularThrobber::OnPaint( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
const FColor FinalColorAndOpacity( InWidgetStyle.GetColorAndOpacityTint() * PieceImage->GetTint( InWidgetStyle ) );
const float Scale = AllottedGeometry.Scale;
const float OffsetX = (AllottedGeometry.Size.X * Scale * 0.5f) - (PieceImage->ImageSize.X * Scale * 0.5f);
const float OffsetY = (AllottedGeometry.Size.Y * Scale * 0.5f) - (PieceImage->ImageSize.Y * Scale * 0.5f);
FPaintGeometry PaintGeom = AllottedGeometry.ToPaintGeometry();
FVector2D Origin = PaintGeom.DrawPosition;
Origin.X += OffsetX;
Origin.Y += OffsetY;
const float DeltaAngle = NumPieces > 0 ? 2 * PI / NumPieces : 0;
const float Phase = Curve.GetLerpLooping() * 2 * PI;
for (int32 PieceIdx = 0; PieceIdx < NumPieces; ++PieceIdx)
{
PaintGeom.DrawPosition.X = Origin.X + FMath::Sin(DeltaAngle * PieceIdx + Phase) * OffsetX;
PaintGeom.DrawPosition.Y = Origin.Y + FMath::Cos(DeltaAngle * PieceIdx + Phase) * OffsetY;
PaintGeom.DrawSize = PieceImage->ImageSize * Scale * (PieceIdx + 1) / NumPieces;
FSlateDrawElement::MakeBox(OutDrawElements, LayerId, PaintGeom, PieceImage, MyClippingRect, ESlateDrawEffect::None, InWidgetStyle.GetColorAndOpacityTint() );
}
return LayerId;
}
/** 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 SFlipbookTimeline::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
LayerId = SCompoundWidget::OnPaint(Args, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
const float CurrentTimeSecs = PlayTime.Get();
UPaperFlipbook* Flipbook = FlipbookBeingEdited.Get();
const float TotalTimeSecs = (Flipbook != nullptr) ? Flipbook->GetTotalDuration() : 0.0f;
const int32 TotalNumFrames = (Flipbook != nullptr) ? Flipbook->GetNumFrames() : 0;
const float SlateTotalDistance = SlateUnitsPerFrame * TotalNumFrames;
const float CurrentTimeXPos = (CurrentTimeSecs / TotalTimeSecs) * SlateTotalDistance;
// Draw a line for the current scrub cursor
++LayerId;
TArray<FVector2D> LinePoints;
LinePoints.Add(FVector2D(CurrentTimeXPos, 0.f));
LinePoints.Add(FVector2D(CurrentTimeXPos, AllottedGeometry.Size.Y));
FSlateDrawElement::MakeLines(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(),
LinePoints,
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Red
);
return LayerId;
}
int32 SSpinningImage::OnPaint( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
const FSlateBrush* ImageBrush = Image.Get();
if ((ImageBrush != NULL) && (ImageBrush->DrawAs != ESlateBrushDrawType::NoDrawType))
{
const bool bIsEnabled = ShouldBeEnabled(bParentEnabled);
const uint32 DrawEffects = bIsEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
const FColor FinalColorAndOpacity( InWidgetStyle.GetColorAndOpacityTint() * ColorAndOpacity.Get().GetColor(InWidgetStyle) * ImageBrush->GetTint( InWidgetStyle ) );
const float Angle = Curve.GetLerpLooping() * 2.0f * PI;
FSlateDrawElement::MakeRotatedBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(),
ImageBrush,
MyClippingRect,
DrawEffects,
Angle,
TOptional<FVector2D>(), // Will auto rotate about center
FSlateDrawElement::RelativeToElement,
FinalColorAndOpacity
);
}
return LayerId;
}
int32 FSlateTextHighlightRunRenderer::OnPaint( const FPaintArgs& Args, const FTextLayout::FLineView& Line, const TSharedRef< ISlateRun >& Run, const TSharedRef< ILayoutBlock >& Block, const FTextBlockStyle& DefaultStyle, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
FVector2D Location( Block->GetLocationOffset() );
Location.Y = Line.Offset.Y;
// The block size and offset values are pre-scaled, so we need to account for that when converting the block offsets into paint geometry
const float InverseScale = Inverse(AllottedGeometry.Scale);
// Draw the actual highlight rectangle
FSlateDrawElement::MakeBox(
OutDrawElements,
++LayerId,
AllottedGeometry.ToPaintGeometry(TransformVector(InverseScale, FVector2D( Block->GetSize().X, Line.Size.Y )), FSlateLayoutTransform(TransformPoint(InverseScale, Location))),
&DefaultStyle.HighlightShape,
MyClippingRect,
bParentEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect,
InWidgetStyle.GetColorAndOpacityTint() * DefaultStyle.HighlightColor
);
FLinearColor InvertedHighlightColor = FLinearColor::White - DefaultStyle.HighlightColor;
InvertedHighlightColor.A = InWidgetStyle.GetForegroundColor().A;
FWidgetStyle WidgetStyle( InWidgetStyle );
WidgetStyle.SetForegroundColor( InvertedHighlightColor );
return Run->OnPaint( Args, Line, Block, DefaultStyle, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, WidgetStyle, bParentEnabled );
}
int32 FSequencerTimeSliderController::OnPaintTimeSlider( bool bMirrorLabels, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
const bool bEnabled = bParentEnabled;
const ESlateDrawEffect::Type DrawEffects = bEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
TRange<float> LocalViewRange = TimeSliderArgs.ViewRange.Get();
const float LocalViewRangeMin = LocalViewRange.GetLowerBoundValue();
const float LocalViewRangeMax = LocalViewRange.GetUpperBoundValue();
const float LocalSequenceLength = LocalViewRangeMax-LocalViewRangeMin;
FVector2D Scale = FVector2D(1.0f,1.0f);
if ( LocalSequenceLength > 0)
{
FScrubRangeToScreen RangeToScreen( LocalViewRange, AllottedGeometry.Size );
const float MajorTickHeight = 9.0f;
FDrawTickArgs Args;
Args.AllottedGeometry = AllottedGeometry;
Args.bMirrorLabels = bMirrorLabels;
Args.bOnlyDrawMajorTicks = false;
Args.TickColor = FLinearColor::White;
Args.ClippingRect = MyClippingRect;
Args.DrawEffects = DrawEffects;
Args.StartLayer = LayerId;
Args.TickOffset = bMirrorLabels ? 0.0f : FMath::Abs( AllottedGeometry.Size.Y - MajorTickHeight );
Args.MajorTickHeight = MajorTickHeight;
DrawTicks( OutDrawElements, RangeToScreen, Args );
const float HandleSize = 13.0f;
float HalfSize = FMath::TruncToFloat(HandleSize/2.0f);
// Draw the scrub handle
const float XPos = RangeToScreen.InputToLocalX( TimeSliderArgs.ScrubPosition.Get() );
// Should draw above the text
const int32 ArrowLayer = LayerId + 2;
FPaintGeometry MyGeometry = AllottedGeometry.ToPaintGeometry( FVector2D( XPos-HalfSize, 0 ), FVector2D( HandleSize, AllottedGeometry.Size.Y ) );
FLinearColor ScrubColor = InWidgetStyle.GetColorAndOpacityTint();
// @todo Sequencer this color should be specified in the style
ScrubColor.A = ScrubColor.A*0.5f;
ScrubColor.B *= 0.1f;
ScrubColor.G *= 0.2f;
FSlateDrawElement::MakeBox(
OutDrawElements,
ArrowLayer,
MyGeometry,
bMirrorLabels ? ScrubHandleUp : ScrubHandleDown,
MyClippingRect,
DrawEffects,
ScrubColor
);
return ArrowLayer;
}
return LayerId;
}
int32 SAnimCurveEd::OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
int32 NewLayerId = SCurveEditor::OnPaint(Args, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled) + 1;
float Value = 0.f;
if(OnGetScrubValue.IsBound())
{
Value = OnGetScrubValue.Execute();
}
FPaintGeometry MyGeometry = AllottedGeometry.ToPaintGeometry();
// scale info
FTrackScaleInfo ScaleInfo(ViewMinInput.Get(), ViewMaxInput.Get(), 0.f, 0.f, AllottedGeometry.Size);
float XPos = ScaleInfo.InputToLocalX(Value);
TArray<FVector2D> LinePoints;
LinePoints.Add(FVector2D(XPos-1, 0.f));
LinePoints.Add(FVector2D(XPos+1, AllottedGeometry.Size.Y));
FSlateDrawElement::MakeLines(
OutDrawElements,
NewLayerId,
MyGeometry,
LinePoints,
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Red
);
// now draw scrub with new layer ID + 1;
return NewLayerId;
}
virtual int32 OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const override
{
float Alpha = Sequencer.Pin()->GetOverlayFadeCurve();
if (Alpha > 0.f)
{
FTimeToPixel TimeToPixelConverter = FTimeToPixel(AllottedGeometry, ViewRange.Get());
TRange<float> TimeBounds = TRange<float>(TimeToPixelConverter.PixelToTime(0),
TimeToPixelConverter.PixelToTime(AllottedGeometry.Size.X));
TArray< TRange<float> > OverlayRanges = ComputeOverlayRanges(TimeBounds, CachedFilteredRanges);
for (int32 i = 0; i < OverlayRanges.Num(); ++i)
{
float LowerBound = TimeToPixelConverter.TimeToPixel(OverlayRanges[i].GetLowerBoundValue());
float UpperBound = TimeToPixelConverter.TimeToPixel(OverlayRanges[i].GetUpperBoundValue());
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(FVector2D(LowerBound, 0), FVector2D(UpperBound - LowerBound, AllottedGeometry.Size.Y)),
FEditorStyle::GetBrush("Sequencer.ShotFilter"),
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor(1.f, 1.f, 1.f, Alpha)
);
}
}
return LayerId;
}
int32 SBorder::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
const FSlateBrush* BrushResource = BorderImage.Get();
const bool bEnabled = ShouldBeEnabled(bParentEnabled);
const bool bShowDisabledEffect = ShowDisabledEffect.Get();
ESlateDrawEffect::Type DrawEffects = bShowDisabledEffect && !bEnabled ? ESlateDrawEffect::DisabledEffect : ESlateDrawEffect::None;
if ( BrushResource && BrushResource->DrawAs != ESlateBrushDrawType::NoDrawType )
{
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(),
BrushResource,
MyClippingRect,
DrawEffects,
BrushResource->GetTint( InWidgetStyle ) * InWidgetStyle.GetColorAndOpacityTint() * BorderBackgroundColor.Get().GetColor( InWidgetStyle )
);
}
FWidgetStyle CompoundedWidgetStyle = FWidgetStyle(InWidgetStyle)
.BlendColorAndOpacityTint(ColorAndOpacity.Get())
.SetForegroundColor( ForegroundColor.Get() );
return SCompoundWidget::OnPaint(Args, AllottedGeometry, MyClippingRect.IntersectionWith( AllottedGeometry.GetClippingRect() ), OutDrawElements, LayerId, CompoundedWidgetStyle, bEnabled );
}
int32 SPropertyTableCell::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
if ( CellBackground && CellBackground->DrawAs != ESlateBrushDrawType::NoDrawType )
{
const FSlateBrush* Background = CellBackground;
if ( Cell->GetTable()->GetCurrentCell() == Cell )
{
Background = GetCurrentCellBorder();
}
else if ( Cell->GetTable()->GetSelectedCells().Contains( Cell.ToSharedRef() ) )
{
Background = FEditorStyle::GetBrush( Style, ".ReadOnlySelectedCellBorder" );
}
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(),
Background,
MyClippingRect,
ESlateDrawEffect::None,
Background->GetTint( InWidgetStyle ) * InWidgetStyle.GetColorAndOpacityTint()
);
}
return SCompoundWidget::OnPaint( Args, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled );
}
int32 SVirtualJoystick::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
int32 RetLayerId = LayerId;
if (bVisible)
{
FLinearColor ColorAndOpacitySRGB = InWidgetStyle.GetColorAndOpacityTint();
ColorAndOpacitySRGB.A = FMath::RoundToInt(255.f * CurrentOpacity);
for (int32 ControlIndex = 0; ControlIndex < Controls.Num(); ControlIndex++)
{
const FControlInfo& Control = Controls[ControlIndex];
if (Control.Image2.IsValid())
{
FSlateDrawElement::MakeBox(
OutDrawElements,
RetLayerId++,
AllottedGeometry.ToPaintGeometry(
Control.VisualCenter - FVector2D(Control.CorrectedVisualSize.X * 0.5f, Control.CorrectedVisualSize.Y * 0.5f),
Control.CorrectedVisualSize),
Control.Image2.Get(),
MyClippingRect,
ESlateDrawEffect::None,
ColorAndOpacitySRGB
);
}
if (Control.Image1.IsValid())
{
FSlateDrawElement::MakeBox(
OutDrawElements,
RetLayerId++,
AllottedGeometry.ToPaintGeometry(
Control.VisualCenter + Control.ThumbPosition - FVector2D(Control.CorrectedThumbSize.X * 0.5f, Control.CorrectedThumbSize.Y * 0.5f),
Control.CorrectedThumbSize),
Control.Image1.Get(),
MyClippingRect,
ESlateDrawEffect::None,
ColorAndOpacitySRGB
);
}
}
}
return RetLayerId;
}
int32 SObjectNameEditableTextBox::OnPaint( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
int32 StartLayer = SCompoundWidget::OnPaint( AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled );
const int32 TextLayer = 1;
// See if a disabled effect should be used
bool bEnabled = ShouldBeEnabled( bParentEnabled );
ESlateDrawEffect::Type DrawEffects = (bEnabled) ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
const double CurrentTime = FSlateApplication::Get().GetCurrentTime();
const float DrawPositionY = ( AllottedGeometry.Size.Y / 2 ) - ( AllottedGeometry.Size.Y / 2 );
// Draw highlight targeting effect
const float TimeSinceHighlightInteraction = (float)( CurrentTime - LastCommittedTime );
if( TimeSinceHighlightInteraction <= HighlightTargetEffectDuration )
{
// Compute animation progress
float EffectAlpha = FMath::Clamp( TimeSinceHighlightInteraction / HighlightTargetEffectDuration, 0.0f, 1.0f );
EffectAlpha = 1.0f - EffectAlpha * EffectAlpha; // Inverse square falloff (looks nicer!)
float EffectOpacity = EffectAlpha;
// Figure out a universally visible highlight color.
FColor HighlightTargetColorAndOpacity = ( (FLinearColor::White - ColorAndOpacity.Get())*0.5f + FLinearColor(+0.4f, +0.1f, -0.2f)) * InWidgetStyle.GetColorAndOpacityTint();
HighlightTargetColorAndOpacity.A = HighlightTargetOpacity * EffectOpacity * 255.0f;
// Compute the bounds offset of the highlight target from where the highlight target spring
// extents currently lie. This is used to "grow" or "shrink" the highlight as needed.
const float CommittingAnimOffset = CommittingAnimOffsetPercent * AllottedGeometry.Size.Y;
// Choose an offset amount depending on whether we're highlighting, or clearing highlight
const float EffectOffset = EffectAlpha * CommittingAnimOffset;
const float HighlightLeftX = HighlightTargetLeftSpring.GetPosition() - EffectOffset;
const float HighlightRightX = HighlightTargetRightSpring.GetPosition() + EffectOffset;
const float HighlightTopY = 0.0f - EffectOffset;
const float HighlightBottomY = AllottedGeometry.Size.Y + EffectOffset;
const FVector2D DrawPosition = FVector2D( HighlightLeftX, HighlightTopY );
const FVector2D DrawSize = FVector2D( HighlightRightX - HighlightLeftX, HighlightBottomY - HighlightTopY );
const FSlateBrush* StyleInfo = FEditorStyle::GetBrush("DetailsView.NameChangeCommitted");
// NOTE: We rely on scissor clipping for the highlight rectangle
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId + TextLayer,
AllottedGeometry.ToPaintGeometry( DrawPosition, DrawSize ), // Position, Size, Scale
StyleInfo, // Style
MyClippingRect, // Clipping rect
DrawEffects, // Effects to use
HighlightTargetColorAndOpacity ); // Color
}
return LayerId + TextLayer;
}
int32 FSequencerTimeSliderController::OnPaintSectionView( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, bool bEnabled, bool bDisplayTickLines, bool bDisplayScrubPosition ) const
{
const ESlateDrawEffect::Type DrawEffects = bEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
TRange<float> LocalViewRange = TimeSliderArgs.ViewRange.Get();
float LocalScrubPosition = TimeSliderArgs.ScrubPosition.Get();
float ViewRange = LocalViewRange.Size<float>();
float PixelsPerInput = ViewRange > 0 ? AllottedGeometry.Size.X / ViewRange : 0;
float LinePos = (LocalScrubPosition - LocalViewRange.GetLowerBoundValue()) * PixelsPerInput;
FScrubRangeToScreen RangeToScreen( LocalViewRange, AllottedGeometry.Size );
if( bDisplayTickLines )
{
// Draw major tick lines in the section area
FDrawTickArgs Args;
Args.AllottedGeometry = AllottedGeometry;
Args.bMirrorLabels = false;
Args.bOnlyDrawMajorTicks = true;
Args.TickColor = FLinearColor( 0.3f, 0.3f, 0.3f, 0.3f );
Args.ClippingRect = MyClippingRect;
Args.DrawEffects = DrawEffects;
// Draw major ticks under sections
Args.StartLayer = LayerId-1;
// Draw the tick the entire height of the section area
Args.TickOffset = 0.0f;
Args.MajorTickHeight = AllottedGeometry.Size.Y;
DrawTicks( OutDrawElements, RangeToScreen, Args );
}
if( bDisplayScrubPosition )
{
// Draw a line for the scrub position
TArray<FVector2D> LinePoints;
LinePoints.AddUninitialized(2);
LinePoints[0] = FVector2D( 1.0f, 0.0f );
LinePoints[1] = FVector2D( 1.0f, FMath::RoundToFloat( AllottedGeometry.Size.Y ) );
FSlateDrawElement::MakeLines(
OutDrawElements,
LayerId+1,
AllottedGeometry.ToPaintGeometry( FVector2D(LinePos, 0.0f ), FVector2D(1.0f,1.0f) ),
LinePoints,
MyClippingRect,
DrawEffects,
FLinearColor::White,
false
);
}
return LayerId;
}
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 FColorPropertySection::OnPaintSection( const FGeometry& AllottedGeometry, const FSlateRect& SectionClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, bool bParentEnabled ) const
{
const ESlateDrawEffect::Type DrawEffects = bParentEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
const UMovieSceneColorSection* ColorSection = Cast<const UMovieSceneColorSection>( &SectionObject );
float StartTime = ColorSection->GetStartTime();
float EndTime = ColorSection->GetEndTime();
float SectionDuration = EndTime - StartTime;
if ( !FMath::IsNearlyZero( SectionDuration ) )
{
LayerId = FPropertySection::OnPaintSection( AllottedGeometry, SectionClippingRect, OutDrawElements, LayerId, bParentEnabled );
FVector2D GradientSize = FVector2D( AllottedGeometry.Size.X, (AllottedGeometry.Size.Y / 4) - 3.0f );
FPaintGeometry PaintGeometry = AllottedGeometry.ToPaintGeometry( FVector2D( 0, 0 ), GradientSize );
// If we are showing a background pattern and the colors is transparent, draw a checker pattern
const FSlateBrush* CheckerBrush = FEditorStyle::GetBrush( "Checker" );
FSlateDrawElement::MakeBox( OutDrawElements, LayerId, PaintGeometry, CheckerBrush, SectionClippingRect, DrawEffects );
TArray<FSlateGradientStop> GradientStops;
TArray< TKeyValuePair<float, FLinearColor> > ColorKeys;
ConsolidateColorCurves( ColorKeys, ColorSection );
for ( int32 i = 0; i < ColorKeys.Num(); ++i )
{
float Time = ColorKeys[i].Key;
FLinearColor Color = ColorKeys[i].Value;
float TimeFraction = (Time - StartTime) / SectionDuration;
GradientStops.Add( FSlateGradientStop( FVector2D( TimeFraction * AllottedGeometry.Size.X, 0 ),
Color ) );
}
if ( GradientStops.Num() > 0 )
{
FSlateDrawElement::MakeGradient(
OutDrawElements,
LayerId + 1,
PaintGeometry,
GradientStops,
Orient_Vertical,
SectionClippingRect,
DrawEffects
);
}
}
return LayerId + 1;
}
void SColorGradientEditor::DrawGradientStopMark( const FGradientStopMark& Mark, const FGeometry& Geometry, float XPos, const FLinearColor& Color, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FSlateRect& InClippingRect, ESlateDrawEffect::Type DrawEffects, bool bColor, const FWidgetStyle& InWidgetStyle ) const
{
static const FSlateBrush* WhiteBrush = FEditorStyle::GetBrush("WhiteBrush");
static const FSlateBrush* ColorStopBrush = FEditorStyle::GetBrush("Sequencer.Timeline.ScrubHandleDown");
static const FSlateBrush* AlphaStopBrush = FEditorStyle::GetBrush("Sequencer.Timeline.ScrubHandleUp");
static const FLinearColor SelectionColor = FEditorStyle::GetSlateColor("SelectionColor").GetColor( InWidgetStyle );
const float HandleSize = 13.0f;
bool bSelected = Mark == SelectedStop;
if( bSelected )
{
// Show selected stops above other stops
++LayerId;
}
// Draw a box for the non colored area
FSlateDrawElement::MakeBox
(
OutDrawElements,
LayerId,
Geometry.ToPaintGeometry( FVector2D( XPos-HandleRect.Left, HandleRect.Top ), FVector2D( HandleRect.Right, HandleRect.Bottom ) ),
bColor ? ColorStopBrush : AlphaStopBrush,
InClippingRect,
DrawEffects,
bSelected ? SelectionColor : FLinearColor::White
);
// Draw a box with the gradient stop color
FSlateDrawElement::MakeBox
(
OutDrawElements,
LayerId+1,
Geometry.ToPaintGeometry( FVector2D( XPos-HandleRect.Left+3, bColor ? HandleRect.Top+3.0f : HandleRect.Top+6), FVector2D( HandleRect.Right-6, HandleRect.Bottom-9 ) ),
WhiteBrush,
InClippingRect,
DrawEffects,
Color.ToFColor(false)
);
}
int32 STrackNode::OnPaint(const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
// We draw ourselves on all of the AllottedGeometry. The parent STrack should have arranged us
FPaintGeometry MyGeometry = AllottedGeometry.ToPaintGeometry();
FVector2D DrawPos(0.f, 0.f);
FVector2D DrawSize = AllottedGeometry.Size;
LastSize = DrawSize; // HACK: Fixme. Need to save this off in case we are drag/dropped
// Background
FLinearColor DrawColor = (IsSelected() ? SelectedNodeColor.Get() : NodeColor.Get());
const FSlateBrush* StyleInfo = FEditorStyle::GetBrush("ProgressBar.Background"); // FIXME: make slate argument for STrackNode
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId++,
MyGeometry,
StyleInfo,
MyClippingRect,
ESlateDrawEffect::None,
DrawColor);
// Text
if (!NodeName.Get().IsEmpty())
{
MyGeometry = AllottedGeometry.ToPaintGeometry( DrawPos + FVector2D(2, 2), DrawSize );
FSlateDrawElement::MakeText(
OutDrawElements,
LayerId++,
MyGeometry,
NodeName.Get(),
Font,
MyClippingRect,
ESlateDrawEffect::None,
FLinearColor::Black//FLinearColor::White//
);
}
return LayerId;
}
void SPaperEditorViewport::PaintSoftwareCursor(const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 DrawLayerId) const
{
if (bShowSoftwareCursor)
{
const FSlateBrush* Brush = FEditorStyle::GetBrush(TEXT("SoftwareCursor_Grab"));
FSlateDrawElement::MakeBox(
OutDrawElements,
DrawLayerId,
AllottedGeometry.ToPaintGeometry( GraphCoordToPanelCoord(SoftwareCursorPosition) - ( Brush->ImageSize / 2 ), Brush->ImageSize ),
Brush,
MyClippingRect);
}
}
int32 FParticleSection::OnPaintSection( const FGeometry& AllottedGeometry, const FSlateRect& SectionClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, bool bParentEnabled ) const
{
UMovieSceneParticleSection* AnimSection = Cast<UMovieSceneParticleSection>(&Section);
FTimeToPixel TimeToPixelConverter( AllottedGeometry, TRange<float>( Section.GetStartTime(), Section.GetEndTime() ) );
EParticleKey::Type KeyType = Cast<UMovieSceneParticleSection>(&Section)->GetKeyType();
// @todo Sequencer Particle Triggers should be sections with 0 duration, but a custom graphic which
// allows them to be dragged around
if (KeyType == EParticleKey::Trigger)
{
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(),
FEditorStyle::GetBrush("Sequencer.GenericSection.Background"),
SectionClippingRect,
ESlateDrawEffect::None,
FLinearColor(0.6f, 0.4f, 0.3f, 1.f)
);
}
else
{
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(),
FEditorStyle::GetBrush("Sequencer.GenericSection.Background"),
SectionClippingRect,
ESlateDrawEffect::None,
FLinearColor(0.8f, 0.4f, 0.3f, 1.f)
);
}
return LayerId+1;
}
virtual int32 OnPaintSection( const FGeometry& AllottedGeometry, const FSlateRect& SectionClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, bool bParentEnabled ) const override
{
// Add a box for the section
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(),
FEditorStyle::GetBrush("Sequencer.GenericSection.Background"),
SectionClippingRect,
ESlateDrawEffect::None,
FColor( 220, 120, 120 )
);
return LayerId;
}
int32 FScrollyZoomy::PaintSoftwareCursorIfNeeded( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId ) const
{
if (bShowSoftwareCursor)
{
const FSlateBrush* Brush = FCoreStyle::Get().GetBrush(TEXT("SoftwareCursor_Grab"));
FSlateDrawElement::MakeBox(
OutDrawElements,
++LayerId,
AllottedGeometry.ToPaintGeometry(SoftwareCursorPosition - (Brush->ImageSize / 2), Brush->ImageSize),
Brush,
MyClippingRect
);
}
return LayerId;
}
int32 FSlateTextUnderlineLineHighlighter::OnPaint(const FPaintArgs& Args, const FTextLayout::FLineView& Line, const float OffsetX, const float Width, const FTextBlockStyle& DefaultStyle, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
TSharedRef<FSlateFontCache> FontCache = FSlateApplication::Get().GetRenderer()->GetFontCache();
const uint16 MaxHeight = FontCache->GetMaxCharacterHeight(FontInfo, AllottedGeometry.Scale);
const int16 Baseline = FontCache->GetBaseline(FontInfo, AllottedGeometry.Scale);
int16 UnderlinePos, UnderlineThickness;
FontCache->GetUnderlineMetrics(FontInfo, AllottedGeometry.Scale, UnderlinePos, UnderlineThickness);
const FVector2D Location(Line.Offset.X + OffsetX, Line.Offset.Y + MaxHeight + Baseline - (UnderlinePos * 0.5f));
const FVector2D Size(Width, FMath::Max<int16>(1, UnderlineThickness));
// The block size and offset values are pre-scaled, so we need to account for that when converting the block offsets into paint geometry
const float InverseScale = Inverse(AllottedGeometry.Scale);
if (Size.X)
{
const FLinearColor LineColorAndOpacity = ColorAndOpacity.GetColor(InWidgetStyle);
const bool ShouldDropShadow = ShadowColorAndOpacity.A > 0.f && ShadowOffset.SizeSquared() > 0.f;
// A negative shadow offset should be applied as a positive offset to the underline to avoid clipping issues
const FVector2D DrawShadowOffset(
(ShadowOffset.X > 0.0f) ? ShadowOffset.X * AllottedGeometry.Scale : 0.0f,
(ShadowOffset.Y > 0.0f) ? ShadowOffset.Y * AllottedGeometry.Scale : 0.0f
);
const FVector2D DrawUnderlineOffset(
(ShadowOffset.X < 0.0f) ? -ShadowOffset.X * AllottedGeometry.Scale : 0.0f,
(ShadowOffset.Y < 0.0f) ? -ShadowOffset.Y * AllottedGeometry.Scale : 0.0f
);
// Draw the optional shadow
if (ShouldDropShadow)
{
FSlateDrawElement::MakeBox(
OutDrawElements,
++LayerId,
AllottedGeometry.ToPaintGeometry(TransformVector(InverseScale, Size), FSlateLayoutTransform(TransformPoint(InverseScale, Location + DrawShadowOffset))),
&UnderlineBrush,
MyClippingRect,
bParentEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect,
ShadowColorAndOpacity * InWidgetStyle.GetColorAndOpacityTint()
);
}
// Draw underline
FSlateDrawElement::MakeBox(
OutDrawElements,
++LayerId,
AllottedGeometry.ToPaintGeometry(TransformVector(InverseScale, Size), FSlateLayoutTransform(TransformPoint(InverseScale, Location + DrawUnderlineOffset))),
&UnderlineBrush,
MyClippingRect,
bParentEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect,
LineColorAndOpacity * InWidgetStyle.GetColorAndOpacityTint()
);
}
return LayerId;
}
int32 SColorWheel::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
const bool bIsEnabled = ShouldBeEnabled(bParentEnabled);
const uint32 DrawEffects = bIsEnabled ? ESlateDrawEffect::None : ESlateDrawEffect::DisabledEffect;
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId,
AllottedGeometry.ToPaintGeometry(),
Image,
MyClippingRect,
DrawEffects,
InWidgetStyle.GetColorAndOpacityTint() * Image->GetTint(InWidgetStyle));
FSlateDrawElement::MakeBox(
OutDrawElements,
LayerId + 1,
AllottedGeometry.ToPaintGeometry(CalcRelativeSelectedPosition() * AllottedGeometry.Size * 0.5f - SelectorImage->ImageSize * 0.5f, SelectorImage->ImageSize),
SelectorImage,
MyClippingRect,
DrawEffects,
InWidgetStyle.GetColorAndOpacityTint() * SelectorImage->GetTint(InWidgetStyle));
return LayerId + 1;
}
int32 SColorBlock::OnPaint( const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
const FSlateBrush* GenericBrush = FCoreStyle::Get().GetBrush( "GenericWhiteBox" );
const ESlateDrawEffect::Type DrawEffects = ESlateDrawEffect::None;
FLinearColor InColor = Color.Get();
if (ColorIsHSV.Get())
{
InColor = InColor.HSVToLinearRGB();
}
if (IgnoreAlpha.Get())
{
InColor.A = 1.f;
}
const FColor DrawColor = InColor.ToFColor(bUseSRGB.Get());
if( ShowBackgroundForAlpha.Get() && DrawColor.A < 255 )
{
// If we are showing a background pattern and the colors is transparent, draw a checker pattern
const FSlateBrush* CheckerBrush = FCoreStyle::Get().GetBrush("ColorPicker.AlphaBackground");
FSlateDrawElement::MakeBox( OutDrawElements, LayerId, AllottedGeometry.ToPaintGeometry(), CheckerBrush, MyClippingRect, DrawEffects );
}
// determine if it is HDR
const float MaxRGB = FMath::Max3(InColor.R, InColor.G, InColor.B);
if (MaxRGB > 1.f)
{
FLinearColor NormalizedLinearColor = InColor / MaxRGB;
NormalizedLinearColor.A = InColor.A;
const FColor DrawNormalizedColor = InWidgetStyle.GetColorAndOpacityTint() * NormalizedLinearColor.ToFColor(bUseSRGB.Get());
FLinearColor ClampedLinearColor = InColor;
ClampedLinearColor.A = InColor.A * MaxRGB;
const FColor DrawClampedColor = InWidgetStyle.GetColorAndOpacityTint() * ClampedLinearColor.ToFColor(bUseSRGB.Get());
TArray<FSlateGradientStop> GradientStops;
GradientStops.Add( FSlateGradientStop( FVector2D::ZeroVector, DrawNormalizedColor ) );
GradientStops.Add( FSlateGradientStop( AllottedGeometry.Size * 0.5f, DrawClampedColor ) );
GradientStops.Add( FSlateGradientStop( AllottedGeometry.Size, DrawNormalizedColor ) );
FSlateDrawElement::MakeGradient(
OutDrawElements,
LayerId + 1,
AllottedGeometry.ToPaintGeometry(),
GradientStops,
(AllottedGeometry.Size.X > AllottedGeometry.Size.Y) ? Orient_Vertical : Orient_Horizontal,
MyClippingRect,
DrawEffects
);
}
else
{
FSlateDrawElement::MakeBox( OutDrawElements, LayerId + 1, AllottedGeometry.ToPaintGeometry(), GenericBrush, MyClippingRect, DrawEffects, InWidgetStyle.GetColorAndOpacityTint() * DrawColor );
}
return LayerId + 1;
}