STextBlock.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/Attribute.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Styling/SlateColor.h"
#include "Input/Reply.h"
#include "Layout/Margin.h"
#include "Styling/SlateWidgetStyleAsset.h"
#include "Fonts/SlateFontInfo.h"
#include "Widgets/SLeafWidget.h"
#include "Styling/SlateTypes.h"
#include "Styling/CoreStyle.h"
#include "Framework/SlateDelegates.h"
#include "Framework/Text/TextLayout.h"
 
class FPaintArgs;
class FSlateWindowElementList;
class FSlateTextBlockLayout;
class IBreakIterator;
enum class ETextShapingMethod : uint8;
 
namespace ETextRole
{
    enum Type
    {
        Custom,
        ButtonText,
        ComboText
    };
}
 
template <>
struct TWidgetTypeTraits<class STextBlock>
{
    static constexpr bool SupportsInvalidation() { return true; }
};
 
class STextBlock : public SLeafWidget
{
    SLATE_DECLARE_WIDGET_API(STextBlock, SLeafWidget, SLATE_API)
 
public:
 
    SLATE_BEGIN_ARGS( STextBlock )
        : _Text()
        , _TextStyle( &FCoreStyle::Get().GetWidgetStyle<FTextBlockStyle>( "NormalText" ) )
        , _Font()
        , _StrikeBrush()
        , _ColorAndOpacity()
        , _ShadowOffset()
        , _ShadowColorAndOpacity()
        , _HighlightColor()
        , _HighlightShape()
        , _HighlightText()
        , _WrapTextAt(0.0f)
        , _AutoWrapText(false)
        , _WrappingPolicy(ETextWrappingPolicy::DefaultWrapping)
        , _TransformPolicy()
        , _Margin()
        , _LineHeightPercentage(1.0f)
        , _ApplyLineHeightToBottomLine(true)
        , _Justification(ETextJustify::Left)
        , _MinDesiredWidth(0.0f)
        , _TextShapingMethod()
        , _TextFlowDirection()
        , _LineBreakPolicy()
        , _OverflowPolicy()
        , _SimpleTextMode(false)
        {
            _Clipping = EWidgetClipping::OnDemand;
        }
 
        SLATE_ATTRIBUTE( FText, Text )
 
        
        SLATE_STYLE_ARGUMENT( FTextBlockStyle, TextStyle )
 
        
        SLATE_ATTRIBUTE( FSlateFontInfo, Font )
 
        
        SLATE_ATTRIBUTE( const FSlateBrush*, StrikeBrush )
 
        
        SLATE_ATTRIBUTE( FSlateColor, ColorAndOpacity )
 
        
        SLATE_ATTRIBUTE( FVector2D, ShadowOffset )
 
        
        SLATE_ATTRIBUTE( FLinearColor, ShadowColorAndOpacity )
 
        
        SLATE_ATTRIBUTE( FLinearColor, HighlightColor )
 
        
        SLATE_ATTRIBUTE( const FSlateBrush*, HighlightShape )
 
        
        SLATE_ATTRIBUTE( FText, HighlightText )
 
        
        SLATE_ATTRIBUTE( float, WrapTextAt )
 
        
        SLATE_ATTRIBUTE( bool, AutoWrapText )
 
        
        SLATE_ATTRIBUTE( ETextWrappingPolicy, WrappingPolicy )
 
        
        SLATE_ATTRIBUTE( ETextTransformPolicy, TransformPolicy )
 
        
        SLATE_ATTRIBUTE( FMargin, Margin )
 
        
        SLATE_ATTRIBUTE( float, LineHeightPercentage )
 
        
        SLATE_ATTRIBUTE( bool, ApplyLineHeightToBottomLine )
 
        
        SLATE_ATTRIBUTE( ETextJustify::Type, Justification )
 
        
        SLATE_ATTRIBUTE( float, MinDesiredWidth )
 
        
        SLATE_ARGUMENT( TOptional<ETextShapingMethod>, TextShapingMethod )
        
        
        SLATE_ARGUMENT( TOptional<ETextFlowDirection>, TextFlowDirection )
 
        
        SLATE_ARGUMENT( TSharedPtr<IBreakIterator>, LineBreakPolicy )
 
        
        SLATE_ARGUMENT(TOptional<ETextOverflowPolicy>, OverflowPolicy)
 
        
        SLATE_ARGUMENT( bool, SimpleTextMode )
 
        
        SLATE_EVENT(FPointerEventHandler, OnDoubleClicked)
 
    SLATE_END_ARGS()
 
    
    SLATE_API STextBlock();
 
    SLATE_API ~STextBlock();
 
    SLATE_API void Construct( const FArguments& InArgs );
 
    const FText& GetText() const
    {
        if (bIsAttributeBoundTextBound)
        {
            STextBlock& MutableSelf = const_cast<STextBlock&>(*this);
            MutableSelf.BoundText.UpdateNow(MutableSelf);
        }
        return BoundText.Get();
    }
    
public:
    SLATE_API void SetText(TAttribute<FText> InText);
 
    SLATE_API void SetHighlightText(TAttribute<FText> InText);
 
    SLATE_API void SetFont(TAttribute<FSlateFontInfo> InFont);
 
    SLATE_API void SetStrikeBrush(TAttribute<const FSlateBrush*> InStrikeBrush);
 
    SLATE_API void SetColorAndOpacity(TAttribute<FSlateColor> InColorAndOpacity);
 
    SLATE_API void SetTextStyle(const FTextBlockStyle* InTextStyle);
 
    SLATE_API void SetTextShapingMethod(const TOptional<ETextShapingMethod>& InTextShapingMethod);
 
    SLATE_API void SetTextFlowDirection(const TOptional<ETextFlowDirection>& InTextFlowDirection);
 
    SLATE_API void SetWrapTextAt(TAttribute<float> InWrapTextAt);
 
    SLATE_API void SetAutoWrapText(TAttribute<bool> InAutoWrapText);
 
    SLATE_API void SetWrappingPolicy(TAttribute<ETextWrappingPolicy> InWrappingPolicy);
 
    SLATE_API void SetTransformPolicy(TAttribute<ETextTransformPolicy> InTransformPolicy);
 
    SLATE_API void SetOverflowPolicy(TOptional<ETextOverflowPolicy> InOverflowPolicy);
 
    SLATE_API void SetShadowOffset(TAttribute<FVector2D> InShadowOffset);
 
    SLATE_API void SetShadowColorAndOpacity(TAttribute<FLinearColor> InShadowColorAndOpacity);
 
    SLATE_API void SetHighlightColor(TAttribute<FLinearColor> InHighlightColor);
    
    SLATE_API void SetHighlightShape(TAttribute<const FSlateBrush*> InHighlightShape);
 
    SLATE_API void SetMinDesiredWidth(TAttribute<float> InMinDesiredWidth);
 
    SLATE_API void SetLineHeightPercentage(TAttribute<float> InLineHeightPercentage);
 
    SLATE_API void SetApplyLineHeightToBottomLine(TAttribute<bool> InApplyLineHeightToBottomLine);
 
    SLATE_API void SetMargin(TAttribute<FMargin> InMargin);
 
    SLATE_API void SetJustification(TAttribute<ETextJustify::Type> InJustification);
 
    // SWidget interface
    SLATE_API virtual int32 OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const override;
    SLATE_API virtual FVector2D ComputeDesiredSize(float) const override;
#if WITH_ACCESSIBILITY
    SLATE_API virtual TSharedRef<FSlateAccessibleWidget> CreateAccessibleWidget() override;
    SLATE_API virtual TOptional<FText> GetDefaultAccessibleText(EAccessibleType AccessibleType = EAccessibleType::Main) const override;
#endif
    // End of SWidget interface
 
public:
    SLATE_API FSlateColor GetColorAndOpacity() const;
 
    SLATE_API const FSlateColor& GetColorAndOpacityRef() const;
 
    SLATE_API FSlateFontInfo GetFont() const;
 
    SLATE_API const FSlateFontInfo& GetFontRef() const;
 
    SLATE_API const FSlateBrush* GetStrikeBrush() const;
 
    SLATE_API ETextTransformPolicy GetTransformPolicyImpl() const;
    
    SLATE_API FVector2f GetShadowOffset() const;
 
    SLATE_API FLinearColor GetShadowColorAndOpacity() const;
 
    SLATE_API const FLinearColor& GetShadowColorAndOpacityRef() const;
 
    SLATE_API FSlateColor GetHighlightColor() const;
 
    SLATE_API const FSlateBrush* GetHighlightShape() const;
 
    SLATE_API FMargin GetMargin() const;
 
    SLATE_API float GetMinDesiredWidth() const;
 
private:
    FTextBlockStyle GetComputedTextStyle() const;
 
    void UpdateTextBlockLayout(float LayoutScaleMultiplier) const;
 
    void InvalidateText(EInvalidateWidgetReason InvalidateReason);
 
private:
    TSlateAttribute<FText> BoundText;
 
    TUniquePtr< FSlateTextBlockLayout > TextLayoutCache;
 
    FTextBlockStyle TextStyle;
 
    TSlateAttribute<FSlateFontInfo> Font;
 
    TSlateAttribute<const FSlateBrush*> StrikeBrush;
 
    TSlateAttribute<FSlateColor> ColorAndOpacity;
 
    TSlateAttribute<FVector2D> ShadowOffset;
 
    TSlateAttribute<FLinearColor> ShadowColorAndOpacity;
 
    TSlateAttribute<FLinearColor> HighlightColor;
 
    TSlateAttribute<const FSlateBrush*> HighlightShape;
 
    TSlateAttribute<FText> HighlightText;
 
    TSlateAttribute<float> WrapTextAt;
 
    TSlateAttribute<bool> AutoWrapText;
 
    TSlateAttribute<ETextWrappingPolicy> WrappingPolicy;
 
    TSlateAttribute<ETextTransformPolicy> TransformPolicy;
 
    TSlateAttribute<FMargin> Margin;
 
    TSlateAttribute<ETextJustify::Type> Justification;
 
    TSlateAttribute<float> LineHeightPercentage;
 
    TSlateAttribute<bool> ApplyLineHeightToBottomLine;
 
    TSlateAttribute<float> MinDesiredWidth;
 
    mutable TOptional<FVector2f> CachedSimpleDesiredSize;
 
    union
    {
        struct 
        {
            //~ for attribute
            uint16 bIsAttributeBoundTextBound : 1;
            uint16 bIsAttributeFontSet : 1;
            uint16 bIsAttributeStrikeBrushSet : 1;
            uint16 bIsAttributeColorAndOpacitySet : 1;
            uint16 bIsAttributeShadowOffsetSet : 1;
            uint16 bIsAttributeShadowColorAndOpacitySet : 1;
            uint16 bIsAttributeHighlightColorSet : 1;
            uint16 bIsAttributeHighlightShapeSet : 1;
            uint16 bIsAttributeWrapTextAtSet : 1;
            uint16 bIsAttributeTransformPolicySet : 1;
            //~ for TextBlockLayout
            mutable uint16 bTextLayoutUpdateTextStyle : 1;
            mutable uint16 bTextLayoutUpdateDesiredSize : 1;
        };
        uint16 Union_Flags;
    };
 
    bool bSimpleTextMode;
};