SEditableTextBox.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Fonts/SlateFontInfo.h"
#include "Framework/MultiBox/MultiBoxExtender.h"
#include "Input/Reply.h"
#include "Layout/Margin.h"
#include "Misc/Attribute.h"
#include "Styling/CoreStyle.h"
#include "Styling/SlateColor.h"
#include "Styling/SlateTypes.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Widgets/Input/SEditableText.h"
#include "Widgets/Layout/SBorder.h"
#include "Framework/SlateDelegates.h"
 
class IErrorReportingWidget;
class SBox;
class SHorizontalBox;
enum class ETextFlowDirection : uint8;
enum class ETextShapingMethod : uint8;
 
class SEditableTextBox : public SBorder
{
 
public:
 
    SLATE_BEGIN_ARGS( SEditableTextBox )
        : _Style(&FCoreStyle::Get().GetWidgetStyle< FEditableTextBoxStyle >("NormalEditableTextBox"))
        , _Text()
        , _HintText()
        , _SearchText()
        , _Font()
        , _ForegroundColor()
        , _ReadOnlyForegroundColor()
        , _FocusedForegroundColor()
        , _IsReadOnly( false )
        , _IsPassword( false )
        , _IsCaretMovedWhenGainFocus ( true )
        , _SelectAllTextWhenFocused( false )
        , _RevertTextOnEscape( false )
        , _ClearKeyboardFocusOnCommit( true )
        , _Justification(ETextJustify::Left)
        , _MaximumLength(-1)
        , _AllowContextMenu(true)
        , _MinDesiredWidth( 0.0f )
        , _SelectAllTextOnCommit( false )
        , _SelectWordOnMouseDoubleClick(true)
        , _BackgroundColor()
        , _Padding()
        , _ErrorReporting()
        , _VirtualKeyboardOptions(FVirtualKeyboardOptions())
        , _VirtualKeyboardTrigger(EVirtualKeyboardTrigger::OnFocusByPointer)
        , _VirtualKeyboardDismissAction(EVirtualKeyboardDismissAction::TextChangeOnDismiss)
        , _OverflowPolicy()
        {
        }
 
        SLATE_STYLE_ARGUMENT( FEditableTextBoxStyle, Style )
 
        
        SLATE_ATTRIBUTE( FText, Text )
 
        
        SLATE_ATTRIBUTE( FText, HintText )
 
        
        SLATE_ATTRIBUTE( FText, SearchText )
 
        
        SLATE_ATTRIBUTE( FSlateFontInfo, Font )
 
        
        SLATE_ATTRIBUTE( FSlateColor, ForegroundColor )
        
        
        SLATE_ATTRIBUTE( FSlateColor, ReadOnlyForegroundColor )
 
        
        SLATE_ATTRIBUTE(FSlateColor, FocusedForegroundColor)
 
        
        SLATE_ATTRIBUTE( bool, IsReadOnly )
 
        
        SLATE_ATTRIBUTE( bool, IsPassword )
 
        
        SLATE_ATTRIBUTE( bool, IsCaretMovedWhenGainFocus )
 
        
        SLATE_ATTRIBUTE( bool, SelectAllTextWhenFocused )
 
        
        SLATE_ATTRIBUTE( bool, RevertTextOnEscape )
 
        
        SLATE_ATTRIBUTE( bool, ClearKeyboardFocusOnCommit )
 
        
        SLATE_ATTRIBUTE(ETextJustify::Type, Justification)
 
        
        SLATE_ATTRIBUTE(int32, MaximumLength)
 
        
        SLATE_ATTRIBUTE(bool, AllowContextMenu)
 
        
        SLATE_EVENT(FOnContextMenuOpening, OnContextMenuOpening)
 
        
        SLATE_EVENT(FMenuExtensionDelegate, ContextMenuExtender)
 
        
        SLATE_EVENT( FOnBeginTextEdit, OnBeginTextEdit )
 
        
        SLATE_EVENT( FOnTextChanged, OnTextChanged )
 
        
        SLATE_EVENT( FOnTextCommitted, OnTextCommitted )
 
        
        SLATE_EVENT( FOnVerifyTextChanged, OnVerifyTextChanged )
 
        
        SLATE_ATTRIBUTE( float, MinDesiredWidth )
 
        
        SLATE_ATTRIBUTE( bool, SelectAllTextOnCommit )
 
        
        SLATE_ATTRIBUTE(bool, SelectWordOnMouseDoubleClick)
 
        
        SLATE_EVENT(FOnKeyChar, OnKeyCharHandler)
 
        
        SLATE_EVENT(FOnKeyDown, OnKeyDownHandler)
 
        
        SLATE_ATTRIBUTE( FSlateColor, BackgroundColor )
 
        
        SLATE_ATTRIBUTE( FMargin, Padding )
 
        
        SLATE_ARGUMENT( TSharedPtr<class IErrorReportingWidget>, ErrorReporting )
 
        
        SLATE_ATTRIBUTE(EKeyboardType, VirtualKeyboardType)
 
        
        SLATE_ARGUMENT(FVirtualKeyboardOptions, VirtualKeyboardOptions)
 
        
        SLATE_ATTRIBUTE(EVirtualKeyboardTrigger, VirtualKeyboardTrigger)
 
        
        SLATE_ATTRIBUTE(EVirtualKeyboardDismissAction, VirtualKeyboardDismissAction)
 
        
        SLATE_ARGUMENT(TOptional<ETextShapingMethod>, TextShapingMethod)
 
        
        SLATE_ARGUMENT(TOptional<ETextFlowDirection>, TextFlowDirection)
 
        
        SLATE_ARGUMENT(TOptional<ETextOverflowPolicy>, OverflowPolicy)
    SLATE_END_ARGS()
 
    SLATE_API SEditableTextBox();
    SLATE_API virtual ~SEditableTextBox();
    
    SLATE_API void Construct( const FArguments& InArgs );
 
    FText GetText() const
    {
        return EditableText->GetText();
    }
 
    SLATE_API void SetStyle(const FEditableTextBoxStyle* InStyle);
 
    SLATE_API void SetTextBlockStyle(const FTextBlockStyle* InTextStyle);
 
    SLATE_API void SetText( const TAttribute< FText >& InNewText );
    
    FText GetHintText() const
    {
        return EditableText->GetHintText();
    }
 
    SLATE_API void SetHintText( const TAttribute< FText >& InHintText );
    
    SLATE_API void SetSearchText(const TAttribute<FText>& InSearchText);
 
    SLATE_API FText GetSearchText() const;
 
    SLATE_API void SetIsReadOnly( TAttribute< bool > InIsReadOnly );
 
    bool IsReadOnly() const { return EditableText->IsTextReadOnly(); }
    
    SLATE_API void SetIsPassword( TAttribute< bool > InIsPassword );
 
    bool IsPassword() const { return EditableText->IsTextPassword(); }
 
    SLATE_API void SetAllowContextMenu(TAttribute< bool > InAllowContextMenu);
 
    SLATE_API void SetVirtualKeyboardDismissAction(TAttribute< EVirtualKeyboardDismissAction > InVirtualKeyboardDismissAction);
    
    SLATE_API void SetFont(const TAttribute<FSlateFontInfo>& InFont);
 
    SLATE_API void SetTextBoxForegroundColor(const TAttribute<FSlateColor>& InForegroundColor);
 
    SLATE_API void SetTextBoxBackgroundColor(const TAttribute<FSlateColor>& InBackgroundColor);
 
    SLATE_API void SetReadOnlyForegroundColor(const TAttribute<FSlateColor>& InReadOnlyForegroundColor);
 
    SLATE_API void SetFocusedForegroundColor(const TAttribute<FSlateColor>& InFocusedForegroundColor);
 
    SLATE_API void SetMaximumLength(const TAttribute<int32>& InMaximumLength);
 
    SLATE_API void SetMinimumDesiredWidth(const TAttribute<float>& InMinimumDesiredWidth);
 
    SLATE_API void SetIsCaretMovedWhenGainFocus(const TAttribute<bool>& InIsCaretMovedWhenGainFocus);
 
    SLATE_API void SetSelectAllTextWhenFocused(const TAttribute<bool>& InSelectAllTextWhenFocused);
 
    SLATE_API void SetRevertTextOnEscape(const TAttribute<bool>& InRevertTextOnEscape);
 
    SLATE_API void SetClearKeyboardFocusOnCommit(const TAttribute<bool>& InClearKeyboardFocusOnCommit);
 
    SLATE_API void SetSelectAllTextOnCommit(const TAttribute<bool>& InSelectAllTextOnCommit);
 
    SLATE_API void SetSelectWordOnMouseDoubleClick(const TAttribute<bool>& InSelectWordOnMouseDoubleClick);
 
    SLATE_API void SetJustification(const TAttribute<ETextJustify::Type>& InJustification);
 
    SLATE_API void SetError( const FText& InError );
    SLATE_API void SetError( const FString& InError );
 
    SLATE_API void SetOnKeyCharHandler(FOnKeyChar InOnKeyCharHandler);
 
    SLATE_API void SetOnKeyDownHandler(FOnKeyDown InOnKeyDownHandler);
 
    SLATE_API void SetTextShapingMethod(const TOptional<ETextShapingMethod>& InTextShapingMethod);
 
    SLATE_API void SetTextFlowDirection(const TOptional<ETextFlowDirection>& InTextFlowDirection);
 
    SLATE_API void SetOverflowPolicy(TOptional<ETextOverflowPolicy> InOverflowPolicy);
 
    SLATE_API bool AnyTextSelected() const;
 
    SLATE_API void SelectAllText();
 
    SLATE_API void ClearSelection();
 
    SLATE_API FText GetSelectedText() const;
 
    SLATE_API void GoTo(const FTextLocation& NewLocation);
 
    void GoTo(const ETextLocation NewLocation)
    {
        EditableText->GoTo(NewLocation);
    }
 
    SLATE_API void ScrollTo(const FTextLocation& NewLocation);
 
    void ScrollTo(const ETextLocation NewLocation)
    {
        EditableText->GoTo(NewLocation);
    }
 
    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 void EnableTextInputMethodContext();
 
    SLATE_API bool HasError() const;
 
    // SWidget overrides
    SLATE_API virtual bool SupportsKeyboardFocus() const override;
    SLATE_API virtual bool HasKeyboardFocus() const override;
    SLATE_API virtual FReply OnFocusReceived( const FGeometry& MyGeometry, const FFocusEvent& InFocusEvent ) override;
    SLATE_API virtual FReply OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent) override;
 
protected:
#if WITH_ACCESSIBILITY
    SLATE_API virtual TSharedRef<FSlateAccessibleWidget> CreateAccessibleWidget() override;
    SLATE_API virtual TOptional<FText> GetDefaultAccessibleText(EAccessibleType AccessibleType = EAccessibleType::Main) const override;
#endif
    SLATE_API void OnEditableTextChanged(const FText& InText);
 
    SLATE_API void OnEditableTextCommitted(const FText& InText, ETextCommit::Type InCommitType);
 
    const FEditableTextBoxStyle* Style;
 
    TSharedPtr< SBox > PaddingBox;
 
    TSharedPtr< SEditableText > EditableText;
 
    TAttribute<FMargin> PaddingOverride;
 
    TAttribute<FSlateFontInfo> FontOverride;
 
    TAttribute<FSlateColor> ForegroundColorOverride;
 
    TAttribute<FSlateColor> BackgroundColorOverride;
 
    TAttribute<FSlateColor> ReadOnlyForegroundColorOverride;
 
    TAttribute<FSlateColor> FocusedForegroundColorOverride;
 
    TAttribute<int32> MaximumLength;
 
    TSharedPtr<SHorizontalBox> Box;
 
    TSharedPtr<class IErrorReportingWidget> ErrorReporting;
 
    FOnTextChanged OnTextChanged;
 
    FOnTextCommitted OnTextCommitted;   
 
    FOnVerifyTextChanged OnVerifyTextChanged;
 
private:
 
    SLATE_API FMargin DeterminePadding() const;
    SLATE_API FSlateFontInfo DetermineFont() const;
    SLATE_API FSlateColor DetermineBackgroundColor() const;
    SLATE_API FSlateColor DetermineForegroundColor() const;
 
    const FSlateBrush* BorderImageNormal;
    const FSlateBrush* BorderImageHovered;
    const FSlateBrush* BorderImageFocused;
    const FSlateBrush* BorderImageReadOnly;
 
    SLATE_API const FSlateBrush* GetBorderImage() const;
 
};