Margin.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Types/SlateEnums.h"
#include "Types/SlateVector2.h"
#include "Margin.generated.h"
 
 
USTRUCT(BlueprintType)
struct FMargin
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Appearance)
    float Left;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Appearance)
    float Top;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Appearance)
    float Right;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Appearance)
    float Bottom;
 
public:
 
    FMargin( )
        : Left(0.0f)
        , Top(0.0f)
        , Right(0.0f)
        , Bottom(0.0f)
    { }
 
    FMargin(float UniformMargin)
        : Left(UniformMargin)
        , Top(UniformMargin)
        , Right(UniformMargin)
        , Bottom(UniformMargin)
    { }
    
    FMargin(float Horizontal, float Vertical)
        : Left(Horizontal)
        , Top(Vertical)
        , Right(Horizontal)
        , Bottom(Vertical)
    { }
 
    FMargin(const FVector2f InVector)
        : Left(InVector.X)
        , Top(InVector.Y)
        , Right(InVector.X)
        , Bottom(InVector.Y)
    { }
 
    FMargin(const FVector2d InVector)
        : Left(UE_REAL_TO_FLOAT(InVector.X))
        , Top(UE_REAL_TO_FLOAT(InVector.Y))
        , Right(UE_REAL_TO_FLOAT(InVector.X))
        , Bottom(UE_REAL_TO_FLOAT(InVector.Y))
    { }
    
    FMargin(double InLeft, double InTop, double InRight, double InBottom)
        : Left((float)InLeft)
        , Top((float)InTop)
        , Right((float)InRight)
        , Bottom((float)InBottom)
    { }
 
    FMargin(const FVector4f InVector)
        : Left(InVector.X)
        , Top(InVector.Y)
        , Right(InVector.Z)
        , Bottom(InVector.W)
    { }
 
    FMargin(const FVector4d InVector)
        : Left(UE_REAL_TO_FLOAT(InVector.X))
        , Top(UE_REAL_TO_FLOAT(InVector.Y))
        , Right(UE_REAL_TO_FLOAT(InVector.Z))
        , Bottom(UE_REAL_TO_FLOAT(InVector.W))
    { }
    
public:
 
    FMargin operator*( float Scale ) const
    {
        return FMargin(Left * Scale, Top * Scale, Right * Scale, Bottom * Scale);
    }
 
    FMargin operator*(const FMargin& InScale) const
    {
        return FMargin(Left * InScale.Left, Top * InScale.Top, Right * InScale.Right, Bottom * InScale.Bottom);
    }
 
    FMargin operator+( const FMargin& InDelta ) const
    {
        return FMargin(Left + InDelta.Left, Top + InDelta.Top, Right + InDelta.Right, Bottom + InDelta.Bottom);
    }
 
    FMargin operator-( const FMargin& Other ) const
    {
        return FMargin(Left - Other.Left, Top - Other.Top, Right - Other.Right, Bottom - Other.Bottom);
    }
 
    bool operator==( const FMargin& Other ) const 
    {
        return (Left == Other.Left) && (Right == Other.Right) && (Top == Other.Top) && (Bottom == Other.Bottom);
    }
 
    bool operator!=( const FMargin& Other ) const 
    {
        return Left != Other.Left || Right != Other.Right || Top != Other.Top || Bottom != Other.Bottom;
    }
 
public:
 
    UE::Slate::FDeprecateVector2DResult GetTopLeft() const
    {
        return UE::Slate::FDeprecateVector2DResult(Left, Top);
    }
    FVector2f GetTopLeft2f() const
    {
        return FVector2f(Left, Top);
    }
 
    UE::Slate::FDeprecateVector2DResult GetDesiredSize() const
    {
        return UE::Slate::FDeprecateVector2DResult(GetDesiredSize2f());
    }
    FVector2f GetDesiredSize2f() const
    {
        return FVector2f(Left + Right, Top + Bottom);
    }
 
    template<EOrientation Orientation>
    float GetTotalSpaceAlong( ) const
    {
        return 0.0f;
    }
};
 
template <> struct TIsPODType<FMargin> { enum { Value = true }; };
 
template<>
inline float FMargin::GetTotalSpaceAlong<Orient_Horizontal>( ) const { return Left + Right; }
 
template<>
inline float FMargin::GetTotalSpaceAlong<Orient_Vertical>( ) const { return Top + Bottom; }