132 lines
7.5 KiB
C++
132 lines
7.5 KiB
C++
#pragma once
|
|
|
|
#include "PanelWidget.hpp"
|
|
|
|
namespace PalUIExtension::Api
|
|
{
|
|
// ------------------------------------------------------------------
|
|
// USizeBox : public UContentWidget : public UPanelWidget.
|
|
//
|
|
// UContentWidget is not in this tree's header dump, so there is no
|
|
// Api::ContentWidget rung to inherit from. This derives from
|
|
// PanelWidget directly, skipping it. That is safe, not a shortcut:
|
|
// Invoke() dispatches through Target->GetFunctionByNameInChain() on
|
|
// the LIVE object's actual engine class chain (USizeBox ->
|
|
// UContentWidget -> UPanelWidget -> UWidget -> ...), never through
|
|
// this wrapper's C++ inheritance. Our wrapper hierarchy only
|
|
// determines which typed accessors are in scope at the call site; it
|
|
// has no effect on what ProcessEvent can reach. UContentWidget itself
|
|
// adds no BlueprintCallable surface beyond what UPanelWidget already
|
|
// gives you (its one member, GetContentSlot(), is a plain C++ helper
|
|
// on the engine side, not a UFUNCTION), so nothing is actually lost
|
|
// by skipping the rung -- there would be nothing to put in it.
|
|
//
|
|
// Every AddChild / GetChildAt / GetAllChildren / GetChildObjects call
|
|
// from PanelWidget works unchanged. SizeBox only adds the
|
|
// override/clear surface below.
|
|
// ------------------------------------------------------------------
|
|
class SizeBox : public PanelWidget
|
|
{
|
|
public:
|
|
static auto ClassPath() -> const TCHAR* { return STR("/Script/UMG.SizeBox"); }
|
|
static auto DebugTag() -> const TCHAR* { return STR("SizeBox"); }
|
|
|
|
SizeBox() = default;
|
|
explicit SizeBox(UObject* Obj)
|
|
: PanelWidget(Obj, ClassOf<SizeBox>(), DebugTag()) {}
|
|
|
|
// ---- setters (write through the UFUNCTION so SynchronizeProperties runs)
|
|
|
|
auto SetWidthOverride(float InWidthOverride) -> bool
|
|
{
|
|
struct P { float InWidthOverride; } p{ InWidthOverride };
|
|
return Call(STR("SetWidthOverride"), p);
|
|
}
|
|
auto SetHeightOverride(float InHeightOverride) -> bool
|
|
{
|
|
struct P { float InHeightOverride; } p{ InHeightOverride };
|
|
return Call(STR("SetHeightOverride"), p);
|
|
}
|
|
auto SetMinDesiredWidth(float InMinDesiredWidth) -> bool
|
|
{
|
|
struct P { float InMinDesiredWidth; } p{ InMinDesiredWidth };
|
|
return Call(STR("SetMinDesiredWidth"), p);
|
|
}
|
|
auto SetMinDesiredHeight(float InMinDesiredHeight) -> bool
|
|
{
|
|
struct P { float InMinDesiredHeight; } p{ InMinDesiredHeight };
|
|
return Call(STR("SetMinDesiredHeight"), p);
|
|
}
|
|
auto SetMaxDesiredWidth(float InMaxDesiredWidth) -> bool
|
|
{
|
|
struct P { float InMaxDesiredWidth; } p{ InMaxDesiredWidth };
|
|
return Call(STR("SetMaxDesiredWidth"), p);
|
|
}
|
|
auto SetMaxDesiredHeight(float InMaxDesiredHeight) -> bool
|
|
{
|
|
struct P { float InMaxDesiredHeight; } p{ InMaxDesiredHeight };
|
|
return Call(STR("SetMaxDesiredHeight"), p);
|
|
}
|
|
auto SetMinAspectRatio(float InMinAspectRatio) -> bool
|
|
{
|
|
struct P { float InMinAspectRatio; } p{ InMinAspectRatio };
|
|
return Call(STR("SetMinAspectRatio"), p);
|
|
}
|
|
auto SetMaxAspectRatio(float InMaxAspectRatio) -> bool
|
|
{
|
|
struct P { float InMaxAspectRatio; } p{ InMaxAspectRatio };
|
|
return Call(STR("SetMaxAspectRatio"), p);
|
|
}
|
|
|
|
// ---- clear (each Set* above also flips its bOverride_ flag on;
|
|
// these are the only way to flip it back off -- there is no
|
|
// "SetWidthOverride with override=false" overload on the engine
|
|
// side, Clear* is a distinct UFUNCTION)
|
|
|
|
auto ClearWidthOverride() -> bool { return CallVoid(STR("ClearWidthOverride")); }
|
|
auto ClearHeightOverride() -> bool { return CallVoid(STR("ClearHeightOverride")); }
|
|
auto ClearMinDesiredWidth() -> bool { return CallVoid(STR("ClearMinDesiredWidth")); }
|
|
auto ClearMinDesiredHeight() -> bool { return CallVoid(STR("ClearMinDesiredHeight")); }
|
|
auto ClearMaxDesiredWidth() -> bool { return CallVoid(STR("ClearMaxDesiredWidth")); }
|
|
auto ClearMaxDesiredHeight() -> bool { return CallVoid(STR("ClearMaxDesiredHeight")); }
|
|
auto ClearMinAspectRatio() -> bool { return CallVoid(STR("ClearMinAspectRatio")); }
|
|
auto ClearMaxAspectRatio() -> bool { return CallVoid(STR("ClearMaxAspectRatio")); }
|
|
|
|
// ---- property reads: the float values ------------------------
|
|
|
|
auto GetWidthOverride() const -> std::optional<float> { return PropertyValue<float>(STR("WidthOverride")); }
|
|
auto GetHeightOverride() const -> std::optional<float> { return PropertyValue<float>(STR("HeightOverride")); }
|
|
auto GetMinDesiredWidth() const -> std::optional<float> { return PropertyValue<float>(STR("MinDesiredWidth")); }
|
|
auto GetMinDesiredHeight() const -> std::optional<float> { return PropertyValue<float>(STR("MinDesiredHeight")); }
|
|
auto GetMaxDesiredWidth() const -> std::optional<float> { return PropertyValue<float>(STR("MaxDesiredWidth")); }
|
|
auto GetMaxDesiredHeight() const -> std::optional<float> { return PropertyValue<float>(STR("MaxDesiredHeight")); }
|
|
auto GetMinAspectRatio() const -> std::optional<float> { return PropertyValue<float>(STR("MinAspectRatio")); }
|
|
auto GetMaxAspectRatio() const -> std::optional<float> { return PropertyValue<float>(STR("MaxAspectRatio")); }
|
|
|
|
// ---- property reads: the override flags -----------------------
|
|
//
|
|
// These are `uint8 bOverride_X : 1;` bitfields, EIGHT of them
|
|
// declared back to back on the header. That is exactly the shape
|
|
// where PropertyValue<uint8>/PropertyPtr<uint8> goes quietly
|
|
// wrong: the compiler is free to pack all eight into one shared
|
|
// byte, and a plain offset+size read would hand back that whole
|
|
// byte -- every flag OR'd together -- for a call asking about
|
|
// just one of them, with no warning, because the property exists
|
|
// and 1 byte does equal sizeof(uint8).
|
|
//
|
|
// PropertyBoolValue (UnrealWrapper.hpp) exists specifically for
|
|
// this: it reads FBoolProperty's own ByteOffset/FieldMask and
|
|
// tests the correct single bit rather than the storage byte. Use
|
|
// it for every bOverride_* flag; do not reach for PropertyValue
|
|
// here even though it would compile.
|
|
auto IsWidthOverridden() const -> std::optional<bool> { return PropertyBoolValue(STR("bOverride_WidthOverride")); }
|
|
auto IsHeightOverridden() const -> std::optional<bool> { return PropertyBoolValue(STR("bOverride_HeightOverride")); }
|
|
auto IsMinDesiredWidthOverridden() const -> std::optional<bool> { return PropertyBoolValue(STR("bOverride_MinDesiredWidth")); }
|
|
auto IsMinDesiredHeightOverridden() const -> std::optional<bool> { return PropertyBoolValue(STR("bOverride_MinDesiredHeight")); }
|
|
auto IsMaxDesiredWidthOverridden() const -> std::optional<bool> { return PropertyBoolValue(STR("bOverride_MaxDesiredWidth")); }
|
|
auto IsMaxDesiredHeightOverridden() const -> std::optional<bool> { return PropertyBoolValue(STR("bOverride_MaxDesiredHeight")); }
|
|
auto IsMinAspectRatioOverridden() const -> std::optional<bool> { return PropertyBoolValue(STR("bOverride_MinAspectRatio")); }
|
|
auto IsMaxAspectRatioOverridden() const -> std::optional<bool> { return PropertyBoolValue(STR("bOverride_MaxAspectRatio")); }
|
|
};
|
|
}
|