SlateEditableTextLayout.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 "Layout/Geometry.h"
#include "Input/Reply.h"
#include "Widgets/SWidget.h"
#include "Layout/Margin.h"
#include "Styling/SlateTypes.h"
#include "Framework/Application/IMenu.h"
#include "Widgets/Input/IVirtualKeyboardEntry.h"
#include "Widgets/Text/ISlateEditableTextWidget.h"
#include "Framework/Text/ITextLayoutMarshaller.h"
#include "Framework/Text/TextLineHighlight.h"
#include "Framework/Text/IRun.h"
#include "Framework/Text/TextLayout.h"
#include "Widgets/Text/SlateEditableTextTypes.h"
#include "Framework/Text/SlateTextLayoutFactory.h"
#include "GenericPlatform/ITextInputMethodSystem.h"
 
class FArrangedChildren;
class FExtender;
class FPaintArgs;
class FSlateWindowElementList;
class FSlateTextBlockLayout;
class FUICommandList;
class IBreakIterator;
class ISlateEditableTextWidget;
class SWindow;
enum class ETextShapingMethod : uint8;
 
class FSlateEditableTextLayout
{
public:
    SLATE_API FSlateEditableTextLayout(ISlateEditableTextWidget& InOwnerWidget, const TAttribute<FText>& InInitialText, FTextBlockStyle InTextStyle, const TOptional<ETextShapingMethod> InTextShapingMethod, const TOptional<ETextFlowDirection> InTextFlowDirection, const FCreateSlateTextLayout& InCreateSlateTextLayout, TSharedRef<ITextLayoutMarshaller> InTextMarshaller, TSharedRef<ITextLayoutMarshaller> InHintTextMarshaller);
    SLATE_API ~FSlateEditableTextLayout();
 
    SLATE_API void SetText(const TAttribute<FText>& InText);
    SLATE_API FText GetText() const;
 
    SLATE_API void SetHintText(const TAttribute<FText>& InHintText);
    SLATE_API FText GetHintText() const;
 
    SLATE_API void SetSearchText(const TAttribute<FText>& InSearchText);
    SLATE_API FText GetSearchText() const;
    
    SLATE_API int32 GetSearchResultIndex() const;
    
    SLATE_API int32 GetNumSearchResults() const;
 
    SLATE_API void SetTextStyle(const FTextBlockStyle& InTextStyle);
    SLATE_API const FTextBlockStyle& GetTextStyle() const;
 
    SLATE_API int32 GetTextLineCount();
 
    SLATE_API void SetCursorBrush(const TAttribute<const FSlateBrush*>& InCursorBrush);
 
    SLATE_API void SetCompositionBrush(const TAttribute<const FSlateBrush*>& InCompositionBrush);
 
    SLATE_API FText GetPlainText() const;
 
    SLATE_API bool SetEditableText(const FText& TextToSet, const bool bForce = false);
 
    SLATE_API FText GetEditableText() const;
 
    SLATE_API FText GetSelectedText() const;
 
    SLATE_API FTextSelection GetSelection() const;
    
    SLATE_API void SetTextShapingMethod(const TOptional<ETextShapingMethod>& InTextShapingMethod);
 
    SLATE_API void SetTextFlowDirection(const TOptional<ETextFlowDirection>& InTextFlowDirection);
 
    SLATE_API void SetTextWrapping(const TAttribute<float>& InWrapTextAt, const TAttribute<bool>& InAutoWrapText, const TAttribute<ETextWrappingPolicy>& InWrappingPolicy);
 
    SLATE_API void SetWrapTextAt(const TAttribute<float>& InWrapTextAt);
 
    SLATE_API void SetAutoWrapText(const TAttribute<bool>& InAutoWrapText);
 
    SLATE_API void SetWrappingPolicy(const TAttribute<ETextWrappingPolicy>& InWrappingPolicy);
 
    SLATE_API void SetMargin(const TAttribute<FMargin>& InMargin);
 
    SLATE_API void SetJustification(const TAttribute<ETextJustify::Type>& InJustification);
 
    SLATE_API void SetLineHeightPercentage(const TAttribute<float>& InLineHeightPercentage);
 
    SLATE_API void SetApplyLineHeightToBottomLine(const TAttribute<bool>& InApplyLineHeightToBottomLine);
 
    SLATE_API void SetOverflowPolicy(TOptional<ETextOverflowPolicy> InOverflowPolicy);
 
    SLATE_API void SetDebugSourceInfo(const TAttribute<FString>& InDebugSourceInfo);
 
    SLATE_API TSharedRef<IVirtualKeyboardEntry> GetVirtualKeyboardEntry() const;
 
    SLATE_API TSharedRef<ITextInputMethodContext> GetTextInputMethodContext() const;
 
    SLATE_API void EnableTextInputMethodContext();
 
    SLATE_API bool Refresh();
 
    SLATE_API void ForceRefreshTextLayout(const FText& CurrentText);
 
    SLATE_API void BeginSearch(const FText& InSearchText, const ESearchCase::Type InSearchCase = ESearchCase::IgnoreCase, const bool InReverse = false);
 
    SLATE_API void AdvanceSearch(const bool InReverse = false);
 
    SLATE_API UE::Slate::FDeprecateVector2DResult SetHorizontalScrollFraction(const float InScrollOffsetFraction);
 
    SLATE_API UE::Slate::FDeprecateVector2DResult SetVerticalScrollFraction(const float InScrollOffsetFraction);
 
    SLATE_API UE::Slate::FDeprecateVector2DResult SetScrollOffset(const UE::Slate::FDeprecateVector2DParameter& InScrollOffset, const FGeometry& InGeometry);
 
    SLATE_API UE::Slate::FDeprecateVector2DResult GetScrollOffset() const;
 
    SLATE_API float GetComputedWrappingWidth() const;
 
    SLATE_API bool GetAutoWrapText() const;
 
    SLATE_API bool HandleFocusReceived(const FFocusEvent& InFocusEvent);
 
    SLATE_API bool HandleFocusLost(const FFocusEvent& InFocusEvent);
 
    SLATE_API FReply HandleKeyChar(const FCharacterEvent& InCharacterEvent);
 
    SLATE_API FReply HandleKeyDown(const FKeyEvent& InKeyEvent);
 
    SLATE_API FReply HandleKeyUp(const FKeyEvent& InKeyEvent);
 
    SLATE_API FReply HandleMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& InMouseEvent);
 
    SLATE_API FReply HandleMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& InMouseEvent);
 
    SLATE_API FReply HandleMouseMove(const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent);
 
    SLATE_API FReply HandleMouseButtonDoubleClick(const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent);
 
    SLATE_API bool HandleEscape();
 
    SLATE_API bool HandleBackspace();
 
    SLATE_API bool HandleDelete();
 
    SLATE_API bool HandleTypeChar(const TCHAR InChar);
 
    SLATE_API bool HandleCarriageReturn(bool isRepeat, int32 UserIndex = 0);
 
    SLATE_API bool CanExecuteDelete() const;
 
    SLATE_API void DeleteSelectedText();
 
    SLATE_API bool AnyTextSelected() const;
 
    SLATE_API bool IsTextSelectedAt(const FGeometry& MyGeometry, const UE::Slate::FDeprecateVector2DParameter& ScreenSpacePosition) const;
 
    SLATE_API bool IsTextSelectedAt(const UE::Slate::FDeprecateVector2DParameter& InLocalPosition) const;
 
    SLATE_API bool CanExecuteSelectAll() const;
 
    SLATE_API void SelectAllText();
 
    SLATE_API void SelectWordAt(const FGeometry& MyGeometry, const UE::Slate::FDeprecateVector2DParameter& ScreenSpacePosition);
 
    SLATE_API void SelectWordAt(const UE::Slate::FDeprecateVector2DParameter& InLocalPosition);
 
    SLATE_API void SelectText(const FTextLocation& InSelectionStart, const FTextLocation& InCursorLocation);
 
    SLATE_API void ClearSelection();
 
    SLATE_API bool CanExecuteCut() const;
 
    SLATE_API void CutSelectedTextToClipboard();
 
    SLATE_API bool CanExecuteCopy() const;
 
    SLATE_API void CopySelectedTextToClipboard();
 
    SLATE_API bool CanExecutePaste() const;
 
    SLATE_API void PasteTextFromClipboard();
 
    SLATE_API void InsertTextAtCursor(const FString& InString);
 
    SLATE_API void InsertRunAtCursor(TSharedRef<IRun> InRun);
 
    SLATE_API bool MoveCursor(const FMoveCursor& InArgs);
 
    SLATE_API void GoTo(const FTextLocation& NewLocation);
 
    SLATE_API void GoTo(const ETextLocation NewLocation);
 
    SLATE_API void JumpTo(ETextLocation JumpLocation, ECursorAction Action);
 
    SLATE_API void ScrollTo(const FTextLocation& NewLocation);
 
    SLATE_API void ScrollTo(const ETextLocation NewLocation);
 
    SLATE_API void UpdateCursorHighlight();
 
    SLATE_API void RemoveCursorHighlight();
 
    SLATE_API void UpdatePreferredCursorScreenOffsetInLine();
 
    SLATE_API void ApplyToSelection(const FRunInfo& InRunInfo, const FTextBlockStyle& InStyle);
 
    SLATE_API TSharedPtr<const IRun> GetRunUnderCursor() const;
 
    SLATE_API TArray<TSharedRef<const IRun>> GetSelectedRuns() const;
 
    SLATE_API FTextLocation GetCursorLocation() const;
 
    SLATE_API FTextLocation TranslatedLocation(const FTextLocation& CurrentLocation, int8 Direction) const;
 
    SLATE_API void TranslateLocationVertical(const FTextLocation& Location, int32 NumLinesToMove, float GeometryScale, FTextLocation& OutCursorPosition, TOptional<SlateEditableTextTypes::ECursorAlignment>& OutCursorAlignment) const;
 
    SLATE_API FTextLocation ScanForWordBoundary(const FTextLocation& Location, int8 Direction) const;
 
    SLATE_API TCHAR GetCharacterAt(const FTextLocation& Location) const;
 
    SLATE_API bool IsAtBeginningOfDocument(const FTextLocation& Location) const;
 
    SLATE_API bool IsAtEndOfDocument(const FTextLocation& Location) const;
 
    SLATE_API bool IsAtBeginningOfLine(const FTextLocation& Location) const;
 
    SLATE_API bool IsAtEndOfLine(const FTextLocation& Location) const;
 
    SLATE_API bool IsAtWordStart(const FTextLocation& Location) const;
 
    SLATE_API void RestoreOriginalText();
 
    SLATE_API bool HasTextChangedFromOriginal() const;
 
    SLATE_API void BeginEditTransation();
 
    SLATE_API void EndEditTransaction();
 
    SLATE_API void PushUndoState(const SlateEditableTextTypes::FUndoState& InUndoState);
 
    SLATE_API void ClearUndoStates();
 
    SLATE_API void MakeUndoState(SlateEditableTextTypes::FUndoState& OutUndoState);
 
    SLATE_API bool CanExecuteUndo() const;
    
    SLATE_API void Undo();
 
    SLATE_API bool CanExecuteRedo() const;
 
    SLATE_API void Redo();
 
    SLATE_API void SaveText(const FText& TextToSave);
 
    SLATE_API void LoadText();
 
    SLATE_API bool ComputeVolatility() const;
 
    SLATE_API void Tick(const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime);
 
    SLATE_API int32 OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled);
 
    SLATE_API void CacheDesiredSize(float LayoutScaleMultiplier);
 
    SLATE_API FVector2D ComputeDesiredSize(float LayoutScaleMultiplier) const;
 
    SLATE_API FChildren* GetChildren();
 
    SLATE_API void OnArrangeChildren(const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren) const;
 
    SLATE_API UE::Slate::FDeprecateVector2DResult GetSize() const;
 
    SLATE_API TSharedRef<SWidget> BuildDefaultContextMenu(const TSharedPtr<FExtender>& InMenuExtender) const;
 
    SLATE_API bool HasActiveContextMenu() const;
 
    SLATE_API void GetCurrentTextLine(FString& OutTextLine) const;
 
    SLATE_API void GetTextLine(const int32 InLineIndex, FString& OutTextLine) const;
 
    /* Function to spawn virtual keyboard on demand */
    SLATE_API void ToggleVirtualKeyboard(bool bShow, const int32 UserIndex);
 
private:
    SLATE_API void InsertTextAtCursorImpl(const FString& InString);
 
    SLATE_API void InsertNewLineAtCursorImpl();
 
    SLATE_API bool RefreshImpl(const FText* InTextToSet, const bool bForce = false);
 
    SLATE_API TSharedRef<IRun> CreateTextOrPasswordRun(const FRunInfo& InRunInfo, const TSharedRef<const FString>& InText, const FTextBlockStyle& InStyle);
 
    SLATE_API void OnContextMenuClosed(TSharedRef<IMenu> Menu);
    
    void UpdateTextChangedByVirtualKeyboard();
 
private:
    friend class FVirtualKeyboardEntry;
    class FVirtualKeyboardEntry : public IVirtualKeyboardEntry
    {
    public:
        static TSharedRef<FVirtualKeyboardEntry> Create(FSlateEditableTextLayout& InOwnerLayout);
 
        virtual void SetTextFromVirtualKeyboard(const FText& InNewText, ETextEntryType TextEntryType) override;
        virtual void SetSelectionFromVirtualKeyboard(int InSelStart, int InSelEnd) override;
        virtual bool GetSelection(int& OutSelStart, int& OutSelEnd) override;
 
        virtual FText GetText() const override;
        virtual FText GetHintText() const override;
        virtual EKeyboardType GetVirtualKeyboardType() const override;
        virtual FVirtualKeyboardOptions GetVirtualKeyboardOptions() const override;
        virtual bool IsMultilineEntry() const override;
        virtual bool IsIntegratedKeyboardEnabled() const override;
 
    private:
        FVirtualKeyboardEntry(FSlateEditableTextLayout& InOwnerLayout);
        FSlateEditableTextLayout* OwnerLayout;
    };
 
private:
    friend class FTextInputMethodContext;
    class FTextInputMethodContext : public ITextInputMethodContext
    {
    public:
        static TSharedRef<FTextInputMethodContext> Create(FSlateEditableTextLayout& InOwnerLayout);
 
        void CacheWindow();
 
        inline void KillContext()
        {
            OwnerLayout = nullptr;
            bIsComposing = false;
        }
 
        inline FTextRange GetCompositionRange() const
        {
            return FTextRange(CompositionBeginIndex, CompositionBeginIndex + CompositionLength);
        }
 
        bool UpdateCachedGeometry(const FGeometry& InAllottedGeometry)
        {
            if (CachedGeometry != InAllottedGeometry)
            {
                CachedGeometry = InAllottedGeometry;
                return true;
            }
            return false;
        }
 
        virtual bool IsComposing() override;
        virtual bool IsReadOnly() override;
        virtual uint32 GetTextLength() override;
        virtual void GetSelectionRange(uint32& BeginIndex, uint32& Length, ECaretPosition& CaretPosition) override;
        virtual void SetSelectionRange(const uint32 BeginIndex, const uint32 Length, const ECaretPosition CaretPosition) override;
        virtual void GetTextInRange(const uint32 BeginIndex, const uint32 Length, FString& OutString) override;
        virtual void SetTextInRange(const uint32 BeginIndex, const uint32 Length, const FString& InString) override;
        virtual int32 GetCharacterIndexFromPoint(const FVector2D& Point) override;
        virtual bool GetTextBounds(const uint32 BeginIndex, const uint32 Length, FVector2D& Position, FVector2D& Size) override;
        virtual void GetScreenBounds(FVector2D& Position, FVector2D& Size) override;
        virtual TSharedPtr<FGenericWindow> GetWindow() override;
        virtual void BeginComposition() override;
        virtual void UpdateCompositionRange(const int32 InBeginIndex, const uint32 InLength) override;
        virtual void EndComposition() override;
 
    private:
        FTextInputMethodContext(FSlateEditableTextLayout& InOwnerLayout);
        FSlateEditableTextLayout* OwnerLayout;
        TWeakPtr<SWindow> CachedParentWindow;
 
        FGeometry CachedGeometry;
        bool bIsComposing;
        int32 CompositionBeginIndex;
        uint32 CompositionLength;
    };
 
private:
    ISlateEditableTextWidget* OwnerWidget;
 
    TSharedPtr<IBreakIterator> GraphemeBreakIterator;
 
    TSharedPtr<ITextLayoutMarshaller> Marshaller;
 
    TSharedPtr<ITextLayoutMarshaller> HintMarshaller;
 
    FCreateSlateTextLayout CreateSlateTextLayout;
 
    TSharedPtr<FSlateTextLayout> TextLayout;
 
    TUniquePtr<FSlateTextBlockLayout> HintTextLayout;
 
    FTextBlockStyle TextStyle;
 
    FTextBlockStyle HintTextStyle;
 
    TAttribute<FText> BoundText;
 
    FTextSnapshot BoundTextLastTick;
 
    bool bWasPasswordLastTick;
 
    TAttribute<FText> HintText;
 
    TAttribute<FText> BoundSearchText;
 
    FTextSnapshot BoundSearchTextLastTick;
 
    FText SearchText;
 
    ESearchCase::Type SearchCase;
 
    TMap<FTextLocation, int32> SearchResultToIndexMap;
 
    int32 CurrentSearchResultIndex;
 
    TAttribute<float> WrapTextAt;
 
    TAttribute<bool> AutoWrapText;
 
    TAttribute<ETextWrappingPolicy> WrappingPolicy;
 
    TAttribute<FMargin> Margin;
 
    TAttribute<ETextJustify::Type> Justification;
 
    TAttribute<float> LineHeightPercentage;
 
    TAttribute<bool> ApplyLineHeightToBottomLine;
 
    TAttribute<FString> DebugSourceInfo;
 
    TSharedPtr<FVirtualKeyboardEntry> VirtualKeyboardEntry;
 
    bool bHasRegisteredTextInputMethodContext;
 
    TSharedPtr<FTextInputMethodContext> TextInputMethodContext;
 
    TSharedPtr<ITextInputMethodChangeNotifier> TextInputMethodChangeNotifier;
 
    TSharedPtr<SlateEditableTextTypes::FCursorLineHighlighter> CursorLineHighlighter;
 
    TSharedPtr<SlateEditableTextTypes::FTextCompositionHighlighter> TextCompositionHighlighter;
 
    TSharedPtr<SlateEditableTextTypes::FTextSelectionHighlighter> TextSelectionHighlighter;
 
    TSharedPtr<SlateEditableTextTypes::FTextSearchHighlighter> SearchSelectionHighlighter;
 
    TArray<FTextLineHighlight> ActiveLineHighlights;
 
    FVector2f ScrollOffset;
 
    TOptional<SlateEditableTextTypes::FScrollInfo> PositionToScrollIntoView;
 
    TOptional<FTextLocation> SelectionStart;
 
    float PreferredCursorScreenOffsetInLine;
 
    SlateEditableTextTypes::FCursorInfo CursorInfo;
 
    TArray<SlateEditableTextTypes::FUndoState> UndoStates;
 
    int32 CurrentUndoLevel;
 
    TOptional<SlateEditableTextTypes::FUndoState> StateBeforeChangingText;
 
    int32 NumTransactionsOpened;
 
    SlateEditableTextTypes::FUndoState OriginalText;
 
    bool bIsDragSelecting;
 
    bool bWasFocusedByLastMouseDown;
 
    bool bHasDragSelectedSinceFocused;
 
    bool bTextChangedByVirtualKeyboard;
 
    bool bTextCommittedByVirtualKeyboard;
 
    FText VirtualKeyboardText;
 
    ETextCommit::Type VirtualKeyboardTextCommitType;
 
    TOptional<ETextOverflowPolicy> OverflowPolicyOverride;
 
    FVector2f CachedSize;
 
    TSharedPtr<FUICommandList> UICommandList;
 
    FActiveTextEditContextMenu ActiveContextMenu;
 
    bool bSelectionChangedExternally;
 
    int ExternalSelectionStart;
    int ExternalSelectionEnd;
 
};