DragAndDrop.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Input/CursorReply.h"
#include "Input/Events.h"
 
class SWidget;
class SWindow;
 
class FDragDropOperation
    : public TSharedFromThis<FDragDropOperation>
{
public:
 
    SLATECORE_API FDragDropOperation();
 
    SLATECORE_API virtual ~FDragDropOperation( );
 
    template<class TType> bool IsOfType() const 
    {
        return IsOfTypeImpl(TType::GetTypeId());
    }
 
    virtual bool AffectedByPointerEvent(const FPointerEvent& PointerEvent) {return true;}
 
    SLATECORE_API virtual void OnDrop( bool bDropWasHandled, const FPointerEvent& MouseEvent );
 
    SLATECORE_API virtual void OnDragged( const class FDragDropEvent& DragDropEvent );
    
    SLATECORE_API virtual FCursorReply OnCursorQuery();
 
    virtual TSharedPtr<SWidget> GetDefaultDecorator() const { return TSharedPtr<SWidget>(); }
 
    virtual FVector2D GetDecoratorPosition() const { return FVector2D(0, 0); }
    
    SLATECORE_API virtual void SetDecoratorVisibility(bool bVisible);
 
    virtual bool IsExternalOperation() const { return false; }
 
    virtual bool IsWindowlessOperation() const { return bCreateNewWindow == false; }
 
    SLATECORE_API void SetCursorOverride( TOptional<EMouseCursor::Type> CursorType );
 
    virtual bool IsOfTypeImpl(const FString& Type) const
    {
        return false;
    }
protected:
 
    SLATECORE_API virtual void Construct();
 
    SLATECORE_API void CreateCursorDecoratorWindow();
 
    SLATECORE_API void DestroyCursorDecoratorWindow();
 
    virtual TSharedPtr<FDragDropOperation> ConvertTo(const FString& TypeId)
    {
        return IsOfTypeImpl(TypeId) ? AsShared() : TSharedPtr<FDragDropOperation>();
    }
 
protected:
 
    bool bCreateNewWindow;
 
    TSharedPtr<SWindow> CursorDecoratorWindow;
 
    TOptional<EMouseCursor::Type> MouseCursor;
 
    TOptional<EMouseCursor::Type> MouseCursorOverride;
};
 
 
class FDragDropEvent : public FPointerEvent
{
public:
     FDragDropEvent( const FPointerEvent& InMouseEvent, const TSharedPtr<FDragDropOperation> InContent )
        : FPointerEvent( InMouseEvent )
        , Content( InContent )
    {
    }
 
    TSharedPtr<FDragDropOperation> GetOperation() const
    {
        return Content;
    }
 
    template<typename OperationType>
    TSharedPtr<OperationType> GetOperationAs() const;
 
private:
    TSharedPtr<FDragDropOperation> Content;
};
 
 
DECLARE_DELEGATE_TwoParams( FOnDragDropEnded,
    bool /* bWasDropHandled */,
    const FDragDropEvent& /* DragDropEvent */
)
 
 
DECLARE_DELEGATE_OneParam( FOnDragDropUpdate,
    const FDragDropEvent& /* DragDropEvent */
)
 
 
 
 
#define DRAG_DROP_OPERATOR_TYPE(TYPE, BASE) \
    static const FString& GetTypeId() { static FString Type = TEXT(#TYPE); return Type; } \
    virtual bool IsOfTypeImpl(const FString& Type) const override { return GetTypeId() == Type || BASE::IsOfTypeImpl(Type); }
 
 
class FExternalDragOperation : public FDragDropOperation
{
private:
    FExternalDragOperation(){}
 
    virtual bool IsExternalOperation() const override { return true; }
 
public:
    DRAG_DROP_OPERATOR_TYPE(FExternalDragOperation, FDragDropOperation)
 
    
    static SLATECORE_API TSharedRef<FExternalDragOperation> NewText( FString InText );
    static SLATECORE_API TSharedRef<FExternalDragOperation> NewFiles( TArray<FString> InFileNames );
    static SLATECORE_API TSharedRef<FExternalDragOperation> NewOperation( FString InText, TArray<FString> InFileNames );
 
    bool HasText() const {return !!(DragType & DragText);}
    bool HasFiles() const {return !!(DragType & DragFiles);}
    
    const FString& GetText() const { ensure(HasText()); return DraggedText;}
    const TArray<FString>& GetFiles() const { ensure(HasFiles()); return DraggedFileNames;}
 
private:
    FString DraggedText;
    TArray<FString> DraggedFileNames;
 
    enum EExternalDragType
    {
        DragText = 1<<0,
        DragFiles = 1<<1,
    };
    uint8 DragType;
};
 
 
class FGameDragDropOperation : public FDragDropOperation
{
public:
    DRAG_DROP_OPERATOR_TYPE(FGameDragDropOperation, FDragDropOperation)
 
    
    SLATECORE_API FGameDragDropOperation();
 
    SLATECORE_API virtual FVector2D GetDecoratorPosition() const override;
 
protected:
    FVector2D DecoratorPosition;
};
 
#include "Input/DragAndDrop.inl" // IWYU pragma: export