initial commit; cv 0.0.3
This commit is contained in:
227
Api/Widget.hpp
Normal file
227
Api/Widget.hpp
Normal file
@@ -0,0 +1,227 @@
|
||||
#pragma once
|
||||
|
||||
#include <Unreal/FText.hpp>
|
||||
#include <Unreal/NameTypes.hpp>
|
||||
|
||||
#include "UmgTypes.hpp"
|
||||
#include "UnrealWrapper.hpp"
|
||||
|
||||
namespace PalUIExtension::Api
|
||||
{
|
||||
|
||||
class Widget : public UnrealWrapper
|
||||
{
|
||||
public:
|
||||
static auto ClassPath() -> const TCHAR* { return STR("/Script/UMG.Widget"); }
|
||||
static auto DebugTag() -> const TCHAR* { return STR("Widget"); }
|
||||
|
||||
Widget() = default;
|
||||
explicit Widget(UObject* Obj) : Widget(Obj, ClassOf<Widget>(), DebugTag()) {}
|
||||
|
||||
// ---- visibility / enable ------------------------------------------
|
||||
|
||||
auto SetVisibility(ESlateVisibility_ InVisibility) -> bool
|
||||
{
|
||||
struct P { ESlateVisibility_ InVisibility; } p{ InVisibility };
|
||||
return Call(STR("SetVisibility"), p);
|
||||
}
|
||||
auto GetVisibility() -> std::optional<ESlateVisibility_>
|
||||
{
|
||||
return CallForReturn<ESlateVisibility_>(STR("GetVisibility"));
|
||||
}
|
||||
|
||||
auto SetIsEnabled(bool bInIsEnabled) -> bool
|
||||
{
|
||||
struct P { bool bInIsEnabled; } p{ bInIsEnabled };
|
||||
return Call(STR("SetIsEnabled"), p);
|
||||
}
|
||||
auto GetIsEnabled() -> std::optional<bool>
|
||||
{
|
||||
return CallForReturn<bool>(STR("GetIsEnabled"));
|
||||
}
|
||||
|
||||
auto IsVisible() -> std::optional<bool> { return CallForReturn<bool>(STR("IsVisible")); }
|
||||
auto IsRendered() -> std::optional<bool> { return CallForReturn<bool>(STR("IsRendered")); }
|
||||
auto IsInViewport() -> std::optional<bool> { return CallForReturn<bool>(STR("IsInViewport")); }
|
||||
auto IsHovered() -> std::optional<bool> { return CallForReturn<bool>(STR("IsHovered")); }
|
||||
|
||||
// ---- render transform ---------------------------------------------
|
||||
|
||||
auto SetRenderTransform(FWidgetTransform_ InTransform) -> bool
|
||||
{
|
||||
struct P { FWidgetTransform_ InTransform; } p{ InTransform };
|
||||
return Call(STR("SetRenderTransform"), p);
|
||||
}
|
||||
auto SetRenderTranslation(FVector2D_ Translation) -> bool
|
||||
{
|
||||
struct P { FVector2D_ Translation; } p{ Translation };
|
||||
return Call(STR("SetRenderTranslation"), p);
|
||||
}
|
||||
auto SetRenderScale(FVector2D_ Scale) -> bool
|
||||
{
|
||||
struct P { FVector2D_ Scale; } p{ Scale };
|
||||
return Call(STR("SetRenderScale"), p);
|
||||
}
|
||||
auto SetRenderShear(FVector2D_ Shear) -> bool
|
||||
{
|
||||
struct P { FVector2D_ Shear; } p{ Shear };
|
||||
return Call(STR("SetRenderShear"), p);
|
||||
}
|
||||
auto SetRenderTransformPivot(FVector2D_ Pivot) -> bool
|
||||
{
|
||||
struct P { FVector2D_ Pivot; } p{ Pivot };
|
||||
return Call(STR("SetRenderTransformPivot"), p);
|
||||
}
|
||||
auto SetRenderTransformAngle(float Angle) -> bool
|
||||
{
|
||||
struct P { float Angle; } p{ Angle };
|
||||
return Call(STR("SetRenderTransformAngle"), p);
|
||||
}
|
||||
auto GetRenderTransformAngle() -> std::optional<float>
|
||||
{
|
||||
return CallForReturn<float>(STR("GetRenderTransformAngle"));
|
||||
}
|
||||
|
||||
auto SetRenderOpacity(float InOpacity) -> bool
|
||||
{
|
||||
struct P { float InOpacity; } p{ InOpacity };
|
||||
return Call(STR("SetRenderOpacity"), p);
|
||||
}
|
||||
auto GetRenderOpacity() -> std::optional<float>
|
||||
{
|
||||
return CallForReturn<float>(STR("GetRenderOpacity"));
|
||||
}
|
||||
|
||||
// ---- clipping / cursor ---------------------------------------------
|
||||
|
||||
auto SetClipping(EWidgetClipping_ InClipping) -> bool
|
||||
{
|
||||
struct P { EWidgetClipping_ InClipping; } p{ InClipping };
|
||||
return Call(STR("SetClipping"), p);
|
||||
}
|
||||
auto GetClipping() -> std::optional<EWidgetClipping_>
|
||||
{
|
||||
return CallForReturn<EWidgetClipping_>(STR("GetClipping"));
|
||||
}
|
||||
|
||||
auto SetCursor(EMouseCursorByte_ InCursor) -> bool
|
||||
{
|
||||
struct P { EMouseCursorByte_ InCursor; } p{ InCursor };
|
||||
return Call(STR("SetCursor"), p);
|
||||
}
|
||||
auto ResetCursor() -> bool { return CallVoid(STR("ResetCursor")); }
|
||||
|
||||
// ---- tooltips -------------------------------------------------------
|
||||
//
|
||||
// FText here is the same ownership question flagged in
|
||||
// FTextFromString: you are handing a refcounted object into a frame
|
||||
// the engine will destruct. Confirm who owns the allocation before
|
||||
// shipping this on a hot path.
|
||||
auto SetToolTipText(const FText& InToolTipText) -> bool
|
||||
{
|
||||
struct P { FText InToolTipText; } p{ InToolTipText };
|
||||
return Call(STR("SetToolTipText"), p);
|
||||
}
|
||||
auto SetToolTip(UObject* InWidget) -> bool
|
||||
{
|
||||
struct P { UObject* Widget; } p{ InWidget };
|
||||
return Call(STR("SetToolTip"), p);
|
||||
}
|
||||
|
||||
// ---- focus ----------------------------------------------------------
|
||||
|
||||
auto SetKeyboardFocus() -> bool { return CallVoid(STR("SetKeyboardFocus")); }
|
||||
auto SetFocus() -> bool { return CallVoid(STR("SetFocus")); }
|
||||
auto SetUserFocus(UObject* PlayerController) -> bool
|
||||
{
|
||||
struct P { UObject* PlayerController; } p{ PlayerController };
|
||||
return Call(STR("SetUserFocus"), p);
|
||||
}
|
||||
|
||||
auto HasKeyboardFocus() -> std::optional<bool> { return CallForReturn<bool>(STR("HasKeyboardFocus")); }
|
||||
auto HasMouseCapture() -> std::optional<bool> { return CallForReturn<bool>(STR("HasMouseCapture")); }
|
||||
auto HasAnyUserFocus() -> std::optional<bool> { return CallForReturn<bool>(STR("HasAnyUserFocus")); }
|
||||
auto HasFocusedDescendants()-> std::optional<bool> { return CallForReturn<bool>(STR("HasFocusedDescendants")); }
|
||||
|
||||
auto HasUserFocus(UObject* PlayerController) -> std::optional<bool>
|
||||
{
|
||||
struct P { UObject* PlayerController; bool ReturnValue; } p{ PlayerController, false };
|
||||
return CallForReturn(STR("HasUserFocus"), p, &P::ReturnValue);
|
||||
}
|
||||
auto HasUserFocusedDescendants(UObject* PlayerController) -> std::optional<bool>
|
||||
{
|
||||
struct P { UObject* PlayerController; bool ReturnValue; } p{ PlayerController, false };
|
||||
return CallForReturn(STR("HasUserFocusedDescendants"), p, &P::ReturnValue);
|
||||
}
|
||||
auto HasMouseCaptureByUser(int32 UserIndex, int32 PointerIndex) -> std::optional<bool>
|
||||
{
|
||||
struct P { int32 UserIndex; int32 PointerIndex; bool ReturnValue; }
|
||||
p{ UserIndex, PointerIndex, false };
|
||||
return CallForReturn(STR("HasMouseCaptureByUser"), p, &P::ReturnValue);
|
||||
}
|
||||
|
||||
// ---- navigation -----------------------------------------------------
|
||||
|
||||
auto SetNavigationRuleBase(EUINavigation_ Direction, EUINavigationRule_ Rule) -> bool
|
||||
{
|
||||
struct P { EUINavigation_ Direction; EUINavigationRule_ Rule; } p{ Direction, Rule };
|
||||
return Call(STR("SetNavigationRuleBase"), p);
|
||||
}
|
||||
auto SetNavigationRuleExplicit(EUINavigation_ Direction, UObject* InWidget) -> bool
|
||||
{
|
||||
struct P { EUINavigation_ Direction; UObject* InWidget; } p{ Direction, InWidget };
|
||||
return Call(STR("SetNavigationRuleExplicit"), p);
|
||||
}
|
||||
auto SetNavigationRule(EUINavigation_ Direction, EUINavigationRule_ Rule, FName WidgetToFocus) -> bool
|
||||
{
|
||||
struct P { EUINavigation_ Direction; EUINavigationRule_ Rule; FName WidgetToFocus; }
|
||||
p{ Direction, Rule, WidgetToFocus };
|
||||
return Call(STR("SetNavigationRule"), p);
|
||||
}
|
||||
auto SetAllNavigationRules(EUINavigationRule_ Rule, FName WidgetToFocus) -> bool
|
||||
{
|
||||
struct P { EUINavigationRule_ Rule; FName WidgetToFocus; } p{ Rule, WidgetToFocus };
|
||||
return Call(STR("SetAllNavigationRules"), p);
|
||||
}
|
||||
|
||||
// ---- layout / lifetime ----------------------------------------------
|
||||
|
||||
auto GetDesiredSize() -> std::optional<FVector2D_>
|
||||
{
|
||||
return CallForReturn<FVector2D_>(STR("GetDesiredSize"));
|
||||
}
|
||||
auto ForceLayoutPrepass() -> bool { return CallVoid(STR("ForceLayoutPrepass")); }
|
||||
auto InvalidateLayoutAndVolatility() -> bool { return CallVoid(STR("InvalidateLayoutAndVolatility")); }
|
||||
auto ForceVolatile(bool bForce) -> bool
|
||||
{
|
||||
struct P { bool bForce; } p{ bForce };
|
||||
return Call(STR("ForceVolatile"), p);
|
||||
}
|
||||
auto RemoveFromParent() -> bool { return CallVoid(STR("RemoveFromParent")); }
|
||||
|
||||
// ---- relationships ---------------------------------------------------
|
||||
//
|
||||
// Returns the raw UPanelWidget*. Not a PanelWidget wrapper, because
|
||||
// PanelWidget derives from this class and cannot be named here.
|
||||
// Wrap it at the call site: PanelWidget{ *w.GetParentObject() }.
|
||||
auto GetParentObject() -> std::optional<UObject*>
|
||||
{
|
||||
return CallForReturn<UObject*>(STR("GetParent"));
|
||||
}
|
||||
|
||||
// UWidget::Slot is a UPROPERTY with no getter.
|
||||
auto GetSlotObject() const -> UObject*
|
||||
{
|
||||
auto Ptr = PropertyPtr<UObject*>(STR("Slot"));
|
||||
return Ptr ? *Ptr : nullptr;
|
||||
}
|
||||
|
||||
auto GetOwningPlayer() -> std::optional<UObject*> { return CallForReturn<UObject*>(STR("GetOwningPlayer")); }
|
||||
auto GetOwningLocalPlayer() -> std::optional<UObject*> { return CallForReturn<UObject*>(STR("GetOwningLocalPlayer")); }
|
||||
auto GetGameInstance() -> std::optional<UObject*> { return CallForReturn<UObject*>(STR("GetGameInstance")); }
|
||||
|
||||
protected:
|
||||
Widget(UObject* Obj, UClass* Expected, const TCHAR* Tag)
|
||||
: UnrealWrapper(Obj, Expected, Tag) {}
|
||||
};
|
||||
}
|
||||
Reference in New Issue
Block a user