gcdsfh145
13626 lines
405 KiB
C++
Executable File
13626 lines
405 KiB
C++
Executable File
//PUBGM(0.13.5)32位SDK
|
|
//作者:清华
|
|
//Telegram:@qinghuanb666
|
|
//生成时间:Fri Apr 18 20:44:39 2025
|
|
|
|
#include "../SDK.hpp"
|
|
|
|
namespace SDK
|
|
{
|
|
//---------------------------------------------------------------------------
|
|
//Functions
|
|
//---------------------------------------------------------------------------
|
|
|
|
// Function UMG.Widget.SetVisibility
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// ESlateVisibility InVisibility (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidget::SetVisibility(ESlateVisibility InVisibility)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetVisibility");
|
|
|
|
UWidget_SetVisibility_Params params;
|
|
params.InVisibility = InVisibility;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetUserFocus
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidget::SetUserFocus(class APlayerController* PlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetUserFocus");
|
|
|
|
UWidget_SetUserFocus_Params params;
|
|
params.PlayerController = PlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetToolTipText
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FText InToolTipText (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UWidget::SetToolTipText(const struct FText& InToolTipText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetToolTipText");
|
|
|
|
UWidget_SetToolTipText_Params params;
|
|
params.InToolTipText = InToolTipText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetToolTip
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidget* Widget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void UWidget::SetToolTip(class UWidget* Widget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetToolTip");
|
|
|
|
UWidget_SetToolTip_Params params;
|
|
params.Widget = Widget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetRenderTranslation
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D Translation (Parm, IsPlainOldData)
|
|
|
|
void UWidget::SetRenderTranslation(const struct FVector2D& Translation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetRenderTranslation");
|
|
|
|
UWidget_SetRenderTranslation_Params params;
|
|
params.Translation = Translation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetRenderTransformPivot
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D Pivot (Parm, IsPlainOldData)
|
|
|
|
void UWidget::SetRenderTransformPivot(const struct FVector2D& Pivot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetRenderTransformPivot");
|
|
|
|
UWidget_SetRenderTransformPivot_Params params;
|
|
params.Pivot = Pivot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetRenderTransform
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FWidgetTransform InTransform (Parm)
|
|
|
|
void UWidget::SetRenderTransform(const struct FWidgetTransform& InTransform)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetRenderTransform");
|
|
|
|
UWidget_SetRenderTransform_Params params;
|
|
params.InTransform = InTransform;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetRenderShear
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D Shear (Parm, IsPlainOldData)
|
|
|
|
void UWidget::SetRenderShear(const struct FVector2D& Shear)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetRenderShear");
|
|
|
|
UWidget_SetRenderShear_Params params;
|
|
params.Shear = Shear;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetRenderScale
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D Scale (Parm, IsPlainOldData)
|
|
|
|
void UWidget::SetRenderScale(const struct FVector2D& Scale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetRenderScale");
|
|
|
|
UWidget_SetRenderScale_Params params;
|
|
params.Scale = Scale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetRenderAngle
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float angle (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidget::SetRenderAngle(float angle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetRenderAngle");
|
|
|
|
UWidget_SetRenderAngle_Params params;
|
|
params.angle = angle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetNavigationRule
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// EUINavigation Direction (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EUINavigationRule Rule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName WidgetToFocus (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidget::SetNavigationRule(EUINavigation Direction, EUINavigationRule Rule, const struct FName& WidgetToFocus)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetNavigationRule");
|
|
|
|
UWidget_SetNavigationRule_Params params;
|
|
params.Direction = Direction;
|
|
params.Rule = Rule;
|
|
params.WidgetToFocus = WidgetToFocus;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetKeyboardFocus
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UWidget::SetKeyboardFocus()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetKeyboardFocus");
|
|
|
|
UWidget_SetKeyboardFocus_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetIsEnabled
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInIsEnabled (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidget::SetIsEnabled(bool bInIsEnabled)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetIsEnabled");
|
|
|
|
UWidget_SetIsEnabled_Params params;
|
|
params.bInIsEnabled = bInIsEnabled;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetCursor
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EMouseCursor> InCursor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidget::SetCursor(TEnumAsByte<EMouseCursor> InCursor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetCursor");
|
|
|
|
UWidget_SetCursor_Params params;
|
|
params.InCursor = InCursor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetClipping
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// EWidgetClipping InClipping (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidget::SetClipping(EWidgetClipping InClipping)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetClipping");
|
|
|
|
UWidget_SetClipping_Params params;
|
|
params.InClipping = InClipping;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.SetAllNavigationRules
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// EUINavigationRule Rule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName WidgetToFocus (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidget::SetAllNavigationRules(EUINavigationRule Rule, const struct FName& WidgetToFocus)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.SetAllNavigationRules");
|
|
|
|
UWidget_SetAllNavigationRules_Params params;
|
|
params.Rule = Rule;
|
|
params.WidgetToFocus = WidgetToFocus;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.ResetCursor
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UWidget::ResetCursor()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.ResetCursor");
|
|
|
|
UWidget_ResetCursor_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.RemoveFromParent
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UWidget::RemoveFromParent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.RemoveFromParent");
|
|
|
|
UWidget_RemoveFromParent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.OnReply__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidget::OnReply__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.OnReply__DelegateSignature");
|
|
|
|
UWidget_OnReply__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.OnPointerEvent__DelegateSignature
|
|
// (Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent MouseEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidget::OnPointerEvent__DelegateSignature(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.OnPointerEvent__DelegateSignature");
|
|
|
|
UWidget_OnPointerEvent__DelegateSignature_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.MouseEvent = MouseEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.IsVisible
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidget::IsVisible()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.IsVisible");
|
|
|
|
UWidget_IsVisible_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.IsHovered
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidget::IsHovered()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.IsHovered");
|
|
|
|
UWidget_IsHovered_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.InvalidateLayoutAndVolatility
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UWidget::InvalidateLayoutAndVolatility()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.InvalidateLayoutAndVolatility");
|
|
|
|
UWidget_InvalidateLayoutAndVolatility_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.HasUserFocusedDescendants
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidget::HasUserFocusedDescendants(class APlayerController* PlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.HasUserFocusedDescendants");
|
|
|
|
UWidget_HasUserFocusedDescendants_Params params;
|
|
params.PlayerController = PlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.HasUserFocus
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidget::HasUserFocus(class APlayerController* PlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.HasUserFocus");
|
|
|
|
UWidget_HasUserFocus_Params params;
|
|
params.PlayerController = PlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.HasMouseCapture
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidget::HasMouseCapture()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.HasMouseCapture");
|
|
|
|
UWidget_HasMouseCapture_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.HasKeyboardFocus
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidget::HasKeyboardFocus()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.HasKeyboardFocus");
|
|
|
|
UWidget_HasKeyboardFocus_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.HasFocusedDescendants
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidget::HasFocusedDescendants()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.HasFocusedDescendants");
|
|
|
|
UWidget_HasFocusedDescendants_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.HasAnyUserFocus
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidget::HasAnyUserFocus()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.HasAnyUserFocus");
|
|
|
|
UWidget_HasAnyUserFocus_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.GetWidget__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// class UWidget* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UWidget* UWidget::GetWidget__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.GetWidget__DelegateSignature");
|
|
|
|
UWidget_GetWidget__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.GetVisibility
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// ESlateVisibility ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
ESlateVisibility UWidget::GetVisibility()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.GetVisibility");
|
|
|
|
UWidget_GetVisibility_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.GetText__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UWidget::GetText__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.GetText__DelegateSignature");
|
|
|
|
UWidget_GetText__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.GetSlateVisibility__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// ESlateVisibility ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
ESlateVisibility UWidget::GetSlateVisibility__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.GetSlateVisibility__DelegateSignature");
|
|
|
|
UWidget_GetSlateVisibility__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.GetSlateColor__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// struct FSlateColor ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FSlateColor UWidget::GetSlateColor__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.GetSlateColor__DelegateSignature");
|
|
|
|
UWidget_GetSlateColor__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.GetSlateBrush__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// struct FSlateBrush ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FSlateBrush UWidget::GetSlateBrush__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.GetSlateBrush__DelegateSignature");
|
|
|
|
UWidget_GetSlateBrush__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.GetParent
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UPanelWidget* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UPanelWidget* UWidget::GetParent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.GetParent");
|
|
|
|
UWidget_GetParent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.GetOwningPlayer
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APlayerController* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APlayerController* UWidget::GetOwningPlayer()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.GetOwningPlayer");
|
|
|
|
UWidget_GetOwningPlayer_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.GetMouseCursor__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// TEnumAsByte<EMouseCursor> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<EMouseCursor> UWidget::GetMouseCursor__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.GetMouseCursor__DelegateSignature");
|
|
|
|
UWidget_GetMouseCursor__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.GetLinearColor__DelegateSignature
|
|
// (Public, Delegate, HasDefaults)
|
|
// Parameters:
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UWidget::GetLinearColor__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.GetLinearColor__DelegateSignature");
|
|
|
|
UWidget_GetLinearColor__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.GetIsEnabled
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidget::GetIsEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.GetIsEnabled");
|
|
|
|
UWidget_GetIsEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.GetInt32__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UWidget::GetInt32__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.GetInt32__DelegateSignature");
|
|
|
|
UWidget_GetInt32__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.GetFloat__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UWidget::GetFloat__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.GetFloat__DelegateSignature");
|
|
|
|
UWidget_GetFloat__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.GetDesiredSize
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UWidget::GetDesiredSize()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.GetDesiredSize");
|
|
|
|
UWidget_GetDesiredSize_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.GetClipping
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// EWidgetClipping ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
EWidgetClipping UWidget::GetClipping()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.GetClipping");
|
|
|
|
UWidget_GetClipping_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.GetCheckBoxState__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// ECheckBoxState ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
ECheckBoxState UWidget::GetCheckBoxState__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.GetCheckBoxState__DelegateSignature");
|
|
|
|
UWidget_GetCheckBoxState__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.GetCachedGeometry
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FGeometry ReturnValue (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, IsPlainOldData)
|
|
|
|
struct FGeometry UWidget::GetCachedGeometry()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.GetCachedGeometry");
|
|
|
|
UWidget_GetCachedGeometry_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.GetCachedAllottedGeometry
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FGeometry ReturnValue (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, IsPlainOldData)
|
|
|
|
struct FGeometry UWidget::GetCachedAllottedGeometry()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.GetCachedAllottedGeometry");
|
|
|
|
UWidget_GetCachedAllottedGeometry_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.GetBool__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidget::GetBool__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.GetBool__DelegateSignature");
|
|
|
|
UWidget_GetBool__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.GenerateWidgetForString__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// struct FString Item (Parm, ZeroConstructor)
|
|
// class UWidget* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UWidget* UWidget::GenerateWidgetForString__DelegateSignature(const struct FString& Item)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.GenerateWidgetForString__DelegateSignature");
|
|
|
|
UWidget_GenerateWidgetForString__DelegateSignature_Params params;
|
|
params.Item = Item;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.Widget.GenerateWidgetForObject__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// class UObject* Item (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UWidget* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UWidget* UWidget::GenerateWidgetForObject__DelegateSignature(class UObject* Item)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.Widget.GenerateWidgetForObject__DelegateSignature");
|
|
|
|
UWidget_GenerateWidgetForObject__DelegateSignature_Params params;
|
|
params.Item = Item;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.ForceVolatile
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bForce (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidget::ForceVolatile(bool bForce)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.ForceVolatile");
|
|
|
|
UWidget_ForceVolatile_Params params;
|
|
params.bForce = bForce;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Widget.ForceLayoutPrepass
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UWidget::ForceLayoutPrepass()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Widget.ForceLayoutPrepass");
|
|
|
|
UWidget_ForceLayoutPrepass_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.UnregisterInputComponent
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
|
|
void UUserWidget::UnregisterInputComponent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.UnregisterInputComponent");
|
|
|
|
UUserWidget_UnregisterInputComponent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.Tick
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// float InDeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::Tick(const struct FGeometry& MyGeometry, float InDeltaTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.Tick");
|
|
|
|
UUserWidget_Tick_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.InDeltaTime = InDeltaTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.StopListeningForInputAction
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ActionName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EInputEvent> EventType (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::StopListeningForInputAction(const struct FName& ActionName, TEnumAsByte<EInputEvent> EventType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.StopListeningForInputAction");
|
|
|
|
UUserWidget_StopListeningForInputAction_Params params;
|
|
params.ActionName = ActionName;
|
|
params.EventType = EventType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.StopListeningForAllInputActions
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
|
|
void UUserWidget::StopListeningForAllInputActions()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.StopListeningForAllInputActions");
|
|
|
|
UUserWidget_StopListeningForAllInputActions_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.StopAnimation
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidgetAnimation* InAnimation (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void UUserWidget::StopAnimation(class UWidgetAnimation* InAnimation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.StopAnimation");
|
|
|
|
UUserWidget_StopAnimation_Params params;
|
|
params.InAnimation = InAnimation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.SetPositionInViewport
|
|
// (Final, BlueprintCosmetic, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D Position (Parm, IsPlainOldData)
|
|
// bool bRemoveDPIScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::SetPositionInViewport(const struct FVector2D& Position, bool bRemoveDPIScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.SetPositionInViewport");
|
|
|
|
UUserWidget_SetPositionInViewport_Params params;
|
|
params.Position = Position;
|
|
params.bRemoveDPIScale = bRemoveDPIScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.SetPlaybackSpeed
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidgetAnimation* InAnimation (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// float PlaybackSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::SetPlaybackSpeed(class UWidgetAnimation* InAnimation, float PlaybackSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.SetPlaybackSpeed");
|
|
|
|
UUserWidget_SetPlaybackSpeed_Params params;
|
|
params.InAnimation = InAnimation;
|
|
params.PlaybackSpeed = PlaybackSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.SetPadding
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UUserWidget::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.SetPadding");
|
|
|
|
UUserWidget_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.SetOwningPlayer
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* LocalPlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::SetOwningPlayer(class APlayerController* LocalPlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.SetOwningPlayer");
|
|
|
|
UUserWidget_SetOwningPlayer_Params params;
|
|
params.LocalPlayerController = LocalPlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.SetOwningLocalPlayer
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class ULocalPlayer* LocalPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::SetOwningLocalPlayer(class ULocalPlayer* LocalPlayer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.SetOwningLocalPlayer");
|
|
|
|
UUserWidget_SetOwningLocalPlayer_Params params;
|
|
params.LocalPlayer = LocalPlayer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.SetNumLoopsToPlay
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidgetAnimation* InAnimation (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// int NumLoopsToPlay (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::SetNumLoopsToPlay(class UWidgetAnimation* InAnimation, int NumLoopsToPlay)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.SetNumLoopsToPlay");
|
|
|
|
UUserWidget_SetNumLoopsToPlay_Params params;
|
|
params.InAnimation = InAnimation;
|
|
params.NumLoopsToPlay = NumLoopsToPlay;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.SetInputActionPriority
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// int NewPriority (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::SetInputActionPriority(int NewPriority)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.SetInputActionPriority");
|
|
|
|
UUserWidget_SetInputActionPriority_Params params;
|
|
params.NewPriority = NewPriority;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.SetInputActionBlocking
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bShouldBlock (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::SetInputActionBlocking(bool bShouldBlock)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.SetInputActionBlocking");
|
|
|
|
UUserWidget_SetInputActionBlocking_Params params;
|
|
params.bShouldBlock = bShouldBlock;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.SetForegroundColor
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSlateColor InForegroundColor (Parm)
|
|
|
|
void UUserWidget::SetForegroundColor(const struct FSlateColor& InForegroundColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.SetForegroundColor");
|
|
|
|
UUserWidget_SetForegroundColor_Params params;
|
|
params.InForegroundColor = InForegroundColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.SetDesiredSizeInViewport
|
|
// (Final, BlueprintCosmetic, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D Size (Parm, IsPlainOldData)
|
|
|
|
void UUserWidget::SetDesiredSizeInViewport(const struct FVector2D& Size)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.SetDesiredSizeInViewport");
|
|
|
|
UUserWidget_SetDesiredSizeInViewport_Params params;
|
|
params.Size = Size;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.SetColorAndOpacity
|
|
// (Final, BlueprintCosmetic, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor InColorAndOpacity (Parm, IsPlainOldData)
|
|
|
|
void UUserWidget::SetColorAndOpacity(const struct FLinearColor& InColorAndOpacity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.SetColorAndOpacity");
|
|
|
|
UUserWidget_SetColorAndOpacity_Params params;
|
|
params.InColorAndOpacity = InColorAndOpacity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.SetAnchorsInViewport
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnchors Anchors (Parm)
|
|
|
|
void UUserWidget::SetAnchorsInViewport(const struct FAnchors& Anchors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.SetAnchorsInViewport");
|
|
|
|
UUserWidget_SetAnchorsInViewport_Params params;
|
|
params.Anchors = Anchors;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.SetAlignmentInViewport
|
|
// (Final, BlueprintCosmetic, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D Alignment (Parm, IsPlainOldData)
|
|
|
|
void UUserWidget::SetAlignmentInViewport(const struct FVector2D& Alignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.SetAlignmentInViewport");
|
|
|
|
UUserWidget_SetAlignmentInViewport_Params params;
|
|
params.Alignment = Alignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.ReverseAnimation
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidgetAnimation* InAnimation (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void UUserWidget::ReverseAnimation(class UWidgetAnimation* InAnimation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.ReverseAnimation");
|
|
|
|
UUserWidget_ReverseAnimation_Params params;
|
|
params.InAnimation = InAnimation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.RemoveFromViewport
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
|
|
void UUserWidget::RemoveFromViewport()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.RemoveFromViewport");
|
|
|
|
UUserWidget_RemoveFromViewport_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.RegisterInputComponent
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
|
|
void UUserWidget::RegisterInputComponent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.RegisterInputComponent");
|
|
|
|
UUserWidget_RegisterInputComponent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.PreConstruct
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// bool IsDesignTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::PreConstruct(bool IsDesignTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.PreConstruct");
|
|
|
|
UUserWidget_PreConstruct_Params params;
|
|
params.IsDesignTime = IsDesignTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.PlaySound
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USoundBase* SoundToPlay (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::PlaySound(class USoundBase* SoundToPlay)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.PlaySound");
|
|
|
|
UUserWidget_PlaySound_Params params;
|
|
params.SoundToPlay = SoundToPlay;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.PlayAnimationTo
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidgetAnimation* InAnimation (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// float StartAtTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float EndAtTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NumLoopsToPlay (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EUMGSequencePlayMode> PlayMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PlaybackSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::PlayAnimationTo(class UWidgetAnimation* InAnimation, float StartAtTime, float EndAtTime, int NumLoopsToPlay, TEnumAsByte<EUMGSequencePlayMode> PlayMode, float PlaybackSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.PlayAnimationTo");
|
|
|
|
UUserWidget_PlayAnimationTo_Params params;
|
|
params.InAnimation = InAnimation;
|
|
params.StartAtTime = StartAtTime;
|
|
params.EndAtTime = EndAtTime;
|
|
params.NumLoopsToPlay = NumLoopsToPlay;
|
|
params.PlayMode = PlayMode;
|
|
params.PlaybackSpeed = PlaybackSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.PlayAnimation
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidgetAnimation* InAnimation (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// float StartAtTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NumLoopsToPlay (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EUMGSequencePlayMode> PlayMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PlaybackSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::PlayAnimation(class UWidgetAnimation* InAnimation, float StartAtTime, int NumLoopsToPlay, TEnumAsByte<EUMGSequencePlayMode> PlayMode, float PlaybackSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.PlayAnimation");
|
|
|
|
UUserWidget_PlayAnimation_Params params;
|
|
params.InAnimation = InAnimation;
|
|
params.StartAtTime = StartAtTime;
|
|
params.NumLoopsToPlay = NumLoopsToPlay;
|
|
params.PlayMode = PlayMode;
|
|
params.PlaybackSpeed = PlaybackSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.PauseAnimation
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidgetAnimation* InAnimation (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UUserWidget::PauseAnimation(class UWidgetAnimation* InAnimation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.PauseAnimation");
|
|
|
|
UUserWidget_PauseAnimation_Params params;
|
|
params.InAnimation = InAnimation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnTouchStarted
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent InTouchEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnTouchStarted(const struct FGeometry& MyGeometry, const struct FPointerEvent& InTouchEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnTouchStarted");
|
|
|
|
UUserWidget_OnTouchStarted_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.InTouchEvent = InTouchEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnTouchMoved
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent InTouchEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnTouchMoved(const struct FGeometry& MyGeometry, const struct FPointerEvent& InTouchEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnTouchMoved");
|
|
|
|
UUserWidget_OnTouchMoved_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.InTouchEvent = InTouchEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnTouchGesture
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent GestureEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnTouchGesture(const struct FGeometry& MyGeometry, const struct FPointerEvent& GestureEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnTouchGesture");
|
|
|
|
UUserWidget_OnTouchGesture_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.GestureEvent = GestureEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnTouchEnded
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent InTouchEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnTouchEnded(const struct FGeometry& MyGeometry, const struct FPointerEvent& InTouchEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnTouchEnded");
|
|
|
|
UUserWidget_OnTouchEnded_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.InTouchEvent = InTouchEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnRemovedFromFocusPath
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FFocusEvent InFocusEvent (Parm)
|
|
|
|
void UUserWidget::OnRemovedFromFocusPath(const struct FFocusEvent& InFocusEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnRemovedFromFocusPath");
|
|
|
|
UUserWidget_OnRemovedFromFocusPath_Params params;
|
|
params.InFocusEvent = InFocusEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnPreviewMouseButtonDown
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent MouseEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnPreviewMouseButtonDown(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnPreviewMouseButtonDown");
|
|
|
|
UUserWidget_OnPreviewMouseButtonDown_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.MouseEvent = MouseEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnPreviewKeyDown
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FKeyEvent InKeyEvent (Parm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnPreviewKeyDown(const struct FGeometry& MyGeometry, const struct FKeyEvent& InKeyEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnPreviewKeyDown");
|
|
|
|
UUserWidget_OnPreviewKeyDown_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.InKeyEvent = InKeyEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnPaint
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// struct FPaintContext Context (Parm, OutParm, ReferenceParm)
|
|
|
|
void UUserWidget::OnPaint(struct FPaintContext* Context)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnPaint");
|
|
|
|
UUserWidget_OnPaint_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Context != nullptr)
|
|
*Context = params.Context;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnMouseWheel
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent MouseEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnMouseWheel(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnMouseWheel");
|
|
|
|
UUserWidget_OnMouseWheel_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.MouseEvent = MouseEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnMouseMove
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent MouseEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnMouseMove(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnMouseMove");
|
|
|
|
UUserWidget_OnMouseMove_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.MouseEvent = MouseEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnMouseLeave
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FPointerEvent MouseEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UUserWidget::OnMouseLeave(const struct FPointerEvent& MouseEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnMouseLeave");
|
|
|
|
UUserWidget_OnMouseLeave_Params params;
|
|
params.MouseEvent = MouseEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnMouseEnter
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent MouseEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UUserWidget::OnMouseEnter(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnMouseEnter");
|
|
|
|
UUserWidget_OnMouseEnter_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.MouseEvent = MouseEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnMouseCaptureLost
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
|
|
void UUserWidget::OnMouseCaptureLost()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnMouseCaptureLost");
|
|
|
|
UUserWidget_OnMouseCaptureLost_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnMouseButtonUp
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent MouseEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnMouseButtonUp(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnMouseButtonUp");
|
|
|
|
UUserWidget_OnMouseButtonUp_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.MouseEvent = MouseEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnMouseButtonDown
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent MouseEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnMouseButtonDown(const struct FGeometry& MyGeometry, const struct FPointerEvent& MouseEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnMouseButtonDown");
|
|
|
|
UUserWidget_OnMouseButtonDown_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.MouseEvent = MouseEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnMouseButtonDoubleClick
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry InMyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent InMouseEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnMouseButtonDoubleClick(const struct FGeometry& InMyGeometry, const struct FPointerEvent& InMouseEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnMouseButtonDoubleClick");
|
|
|
|
UUserWidget_OnMouseButtonDoubleClick_Params params;
|
|
params.InMyGeometry = InMyGeometry;
|
|
params.InMouseEvent = InMouseEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnMotionDetected
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FMotionEvent InMotionEvent (Parm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnMotionDetected(const struct FGeometry& MyGeometry, const struct FMotionEvent& InMotionEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnMotionDetected");
|
|
|
|
UUserWidget_OnMotionDetected_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.InMotionEvent = InMotionEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnKeyUp
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FKeyEvent InKeyEvent (Parm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnKeyUp(const struct FGeometry& MyGeometry, const struct FKeyEvent& InKeyEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnKeyUp");
|
|
|
|
UUserWidget_OnKeyUp_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.InKeyEvent = InKeyEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnKeyDown
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FKeyEvent InKeyEvent (Parm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnKeyDown(const struct FGeometry& MyGeometry, const struct FKeyEvent& InKeyEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnKeyDown");
|
|
|
|
UUserWidget_OnKeyDown_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.InKeyEvent = InKeyEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnKeyChar
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FCharacterEvent InCharacterEvent (Parm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnKeyChar(const struct FGeometry& MyGeometry, const struct FCharacterEvent& InCharacterEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnKeyChar");
|
|
|
|
UUserWidget_OnKeyChar_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.InCharacterEvent = InCharacterEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnFocusReceived
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FFocusEvent InFocusEvent (Parm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnFocusReceived(const struct FGeometry& MyGeometry, const struct FFocusEvent& InFocusEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnFocusReceived");
|
|
|
|
UUserWidget_OnFocusReceived_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.InFocusEvent = InFocusEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnFocusLost
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FFocusEvent InFocusEvent (Parm)
|
|
|
|
void UUserWidget::OnFocusLost(const struct FFocusEvent& InFocusEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnFocusLost");
|
|
|
|
UUserWidget_OnFocusLost_Params params;
|
|
params.InFocusEvent = InFocusEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnDrop
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent PointerEvent (Parm)
|
|
// class UDragDropOperation* Operation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UUserWidget::OnDrop(const struct FGeometry& MyGeometry, const struct FPointerEvent& PointerEvent, class UDragDropOperation* Operation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnDrop");
|
|
|
|
UUserWidget_OnDrop_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.PointerEvent = PointerEvent;
|
|
params.Operation = Operation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnDragOver
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent PointerEvent (Parm)
|
|
// class UDragDropOperation* Operation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UUserWidget::OnDragOver(const struct FGeometry& MyGeometry, const struct FPointerEvent& PointerEvent, class UDragDropOperation* Operation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnDragOver");
|
|
|
|
UUserWidget_OnDragOver_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.PointerEvent = PointerEvent;
|
|
params.Operation = Operation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnDragLeave
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FPointerEvent PointerEvent (Parm)
|
|
// class UDragDropOperation* Operation (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::OnDragLeave(const struct FPointerEvent& PointerEvent, class UDragDropOperation* Operation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnDragLeave");
|
|
|
|
UUserWidget_OnDragLeave_Params params;
|
|
params.PointerEvent = PointerEvent;
|
|
params.Operation = Operation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnDragEnter
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent PointerEvent (Parm)
|
|
// class UDragDropOperation* Operation (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::OnDragEnter(const struct FGeometry& MyGeometry, const struct FPointerEvent& PointerEvent, class UDragDropOperation* Operation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnDragEnter");
|
|
|
|
UUserWidget_OnDragEnter_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.PointerEvent = PointerEvent;
|
|
params.Operation = Operation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnDragDetected
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FPointerEvent PointerEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// class UDragDropOperation* Operation (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::OnDragDetected(const struct FGeometry& MyGeometry, const struct FPointerEvent& PointerEvent, class UDragDropOperation** Operation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnDragDetected");
|
|
|
|
UUserWidget_OnDragDetected_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.PointerEvent = PointerEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Operation != nullptr)
|
|
*Operation = params.Operation;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnDragCancelled
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FPointerEvent PointerEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// class UDragDropOperation* Operation (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::OnDragCancelled(const struct FPointerEvent& PointerEvent, class UDragDropOperation* Operation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnDragCancelled");
|
|
|
|
UUserWidget_OnDragCancelled_Params params;
|
|
params.PointerEvent = PointerEvent;
|
|
params.Operation = Operation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnAnimationStarted
|
|
// (BlueprintCosmetic, Native, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class UWidgetAnimation* Animation (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void UUserWidget::OnAnimationStarted(class UWidgetAnimation* Animation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnAnimationStarted");
|
|
|
|
UUserWidget_OnAnimationStarted_Params params;
|
|
params.Animation = Animation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnAnimationFinished
|
|
// (BlueprintCosmetic, Native, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class UWidgetAnimation* Animation (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void UUserWidget::OnAnimationFinished(class UWidgetAnimation* Animation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnAnimationFinished");
|
|
|
|
UUserWidget_OnAnimationFinished_Params params;
|
|
params.Animation = Animation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnAnalogValueChanged
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FGeometry MyGeometry (Parm, IsPlainOldData)
|
|
// struct FAnalogInputEvent InAnalogInputEvent (Parm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UUserWidget::OnAnalogValueChanged(const struct FGeometry& MyGeometry, const struct FAnalogInputEvent& InAnalogInputEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnAnalogValueChanged");
|
|
|
|
UUserWidget_OnAnalogValueChanged_Params params;
|
|
params.MyGeometry = MyGeometry;
|
|
params.InAnalogInputEvent = InAnalogInputEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.OnAddedToFocusPath
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FFocusEvent InFocusEvent (Parm)
|
|
|
|
void UUserWidget::OnAddedToFocusPath(const struct FFocusEvent& InFocusEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.OnAddedToFocusPath");
|
|
|
|
UUserWidget_OnAddedToFocusPath_Params params;
|
|
params.InFocusEvent = InFocusEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.ListenForInputAction
|
|
// (Final, Native, Protected, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ActionName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EInputEvent> EventType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bConsume (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FScriptDelegate Callback (Parm, ZeroConstructor)
|
|
|
|
void UUserWidget::ListenForInputAction(const struct FName& ActionName, TEnumAsByte<EInputEvent> EventType, bool bConsume, const struct FScriptDelegate& Callback)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.ListenForInputAction");
|
|
|
|
UUserWidget_ListenForInputAction_Params params;
|
|
params.ActionName = ActionName;
|
|
params.EventType = EventType;
|
|
params.bConsume = bConsume;
|
|
params.Callback = Callback;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.IsPlayingAnimation
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UUserWidget::IsPlayingAnimation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.IsPlayingAnimation");
|
|
|
|
UUserWidget_IsPlayingAnimation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.IsListeningForInputAction
|
|
// (Final, Native, Protected, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName ActionName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UUserWidget::IsListeningForInputAction(const struct FName& ActionName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.IsListeningForInputAction");
|
|
|
|
UUserWidget_IsListeningForInputAction_Params params;
|
|
params.ActionName = ActionName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.IsInViewport
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UUserWidget::IsInViewport()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.IsInViewport");
|
|
|
|
UUserWidget_IsInViewport_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.IsInteractable
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UUserWidget::IsInteractable()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.IsInteractable");
|
|
|
|
UUserWidget_IsInteractable_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.IsAnyAnimationPlaying
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UUserWidget::IsAnyAnimationPlaying()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.IsAnyAnimationPlaying");
|
|
|
|
UUserWidget_IsAnyAnimationPlaying_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.IsAnimationPlayingForward
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidgetAnimation* InAnimation (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UUserWidget::IsAnimationPlayingForward(class UWidgetAnimation* InAnimation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.IsAnimationPlayingForward");
|
|
|
|
UUserWidget_IsAnimationPlayingForward_Params params;
|
|
params.InAnimation = InAnimation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.IsAnimationPlaying
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UWidgetAnimation* InAnimation (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UUserWidget::IsAnimationPlaying(class UWidgetAnimation* InAnimation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.IsAnimationPlaying");
|
|
|
|
UUserWidget_IsAnimationPlaying_Params params;
|
|
params.InAnimation = InAnimation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.GetWidgetFromName
|
|
// (Final, Native, Public, HasOutParms, Const)
|
|
// Parameters:
|
|
// struct FName Name (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// class UWidget* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UWidget* UUserWidget::GetWidgetFromName(const struct FName& Name)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.GetWidgetFromName");
|
|
|
|
UUserWidget_GetWidgetFromName_Params params;
|
|
params.Name = Name;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.GetOwningPlayerPawn
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APawn* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APawn* UUserWidget::GetOwningPlayerPawn()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.GetOwningPlayerPawn");
|
|
|
|
UUserWidget_GetOwningPlayerPawn_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.GetOwningPlayer
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APlayerController* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APlayerController* UUserWidget::GetOwningPlayer()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.GetOwningPlayer");
|
|
|
|
UUserWidget_GetOwningPlayer_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.GetOwningLocalPlayer
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class ULocalPlayer* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class ULocalPlayer* UUserWidget::GetOwningLocalPlayer()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.GetOwningLocalPlayer");
|
|
|
|
UUserWidget_GetOwningLocalPlayer_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.GetIsVisible
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UUserWidget::GetIsVisible()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.GetIsVisible");
|
|
|
|
UUserWidget_GetIsVisible_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.GetAnimationCurrentTime
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UWidgetAnimation* InAnimation (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UUserWidget::GetAnimationCurrentTime(class UWidgetAnimation* InAnimation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.GetAnimationCurrentTime");
|
|
|
|
UUserWidget_GetAnimationCurrentTime_Params params;
|
|
params.InAnimation = InAnimation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.GetAnchorsInViewport
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FAnchors ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FAnchors UUserWidget::GetAnchorsInViewport()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.GetAnchorsInViewport");
|
|
|
|
UUserWidget_GetAnchorsInViewport_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.GetAlignmentInViewport
|
|
// (Final, BlueprintCosmetic, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UUserWidget::GetAlignmentInViewport()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.GetAlignmentInViewport");
|
|
|
|
UUserWidget_GetAlignmentInViewport_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.Destruct
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
|
|
void UUserWidget::Destruct()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.Destruct");
|
|
|
|
UUserWidget_Destruct_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.Construct
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
|
|
void UUserWidget::Construct()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.Construct");
|
|
|
|
UUserWidget_Construct_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.AddToViewport
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int ZOrder (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUserWidget::AddToViewport(int ZOrder)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.AddToViewport");
|
|
|
|
UUserWidget_AddToViewport_Params params;
|
|
params.ZOrder = ZOrder;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UserWidget.AddToPlayerScreen
|
|
// (Final, BlueprintCosmetic, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int ZOrder (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UUserWidget::AddToPlayerScreen(int ZOrder)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UserWidget.AddToPlayerScreen");
|
|
|
|
UUserWidget_AddToPlayerScreen_Params params;
|
|
params.ZOrder = ZOrder;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.PanelWidget.RemoveChildAt
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPanelWidget::RemoveChildAt(int Index)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.PanelWidget.RemoveChildAt");
|
|
|
|
UPanelWidget_RemoveChildAt_Params params;
|
|
params.Index = Index;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.PanelWidget.RemoveChild
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidget* content (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPanelWidget::RemoveChild(class UWidget* content)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.PanelWidget.RemoveChild");
|
|
|
|
UPanelWidget_RemoveChild_Params params;
|
|
params.content = content;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.PanelWidget.HasChild
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UWidget* content (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPanelWidget::HasChild(class UWidget* content)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.PanelWidget.HasChild");
|
|
|
|
UPanelWidget_HasChild_Params params;
|
|
params.content = content;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.PanelWidget.HasAnyChildren
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPanelWidget::HasAnyChildren()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.PanelWidget.HasAnyChildren");
|
|
|
|
UPanelWidget_HasAnyChildren_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.PanelWidget.GetChildrenCount
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UPanelWidget::GetChildrenCount()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.PanelWidget.GetChildrenCount");
|
|
|
|
UPanelWidget_GetChildrenCount_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.PanelWidget.GetChildIndex
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UWidget* content (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UPanelWidget::GetChildIndex(class UWidget* content)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.PanelWidget.GetChildIndex");
|
|
|
|
UPanelWidget_GetChildIndex_Params params;
|
|
params.content = content;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.PanelWidget.GetChildAt
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UWidget* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UWidget* UPanelWidget::GetChildAt(int Index)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.PanelWidget.GetChildAt");
|
|
|
|
UPanelWidget_GetChildAt_Params params;
|
|
params.Index = Index;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.PanelWidget.ClearChildren
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UPanelWidget::ClearChildren()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.PanelWidget.ClearChildren");
|
|
|
|
UPanelWidget_ClearChildren_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.PanelWidget.AddChild
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidget* content (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UPanelSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UPanelSlot* UPanelWidget::AddChild(class UWidget* content)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.PanelWidget.AddChild");
|
|
|
|
UPanelWidget_AddChild_Params params;
|
|
params.content = content;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.AsyncTaskDownloadImage.DownloadImage
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString URL (Parm, ZeroConstructor)
|
|
// class UAsyncTaskDownloadImage* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAsyncTaskDownloadImage* UAsyncTaskDownloadImage::DownloadImage(const struct FString& URL)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.AsyncTaskDownloadImage.DownloadImage");
|
|
|
|
UAsyncTaskDownloadImage_DownloadImage_Params params;
|
|
params.URL = URL;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.ContentWidget.SetContent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidget* content (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UPanelSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UPanelSlot* UContentWidget::SetContent(class UWidget* content)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ContentWidget.SetContent");
|
|
|
|
UContentWidget_SetContent_Params params;
|
|
params.content = content;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.ContentWidget.GetContentSlot
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UPanelSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UPanelSlot* UContentWidget::GetContentSlot()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ContentWidget.GetContentSlot");
|
|
|
|
UContentWidget_GetContentSlot_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.ContentWidget.GetContent
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UWidget* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UWidget* UContentWidget::GetContent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ContentWidget.GetContent");
|
|
|
|
UContentWidget_GetContent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.BackgroundBlur.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBackgroundBlur::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BackgroundBlur.SetVerticalAlignment");
|
|
|
|
UBackgroundBlur_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.BackgroundBlur.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UBackgroundBlur::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BackgroundBlur.SetPadding");
|
|
|
|
UBackgroundBlur_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.BackgroundBlur.SetLowQualityFallbackBrush
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSlateBrush InBrush (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UBackgroundBlur::SetLowQualityFallbackBrush(const struct FSlateBrush& InBrush)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BackgroundBlur.SetLowQualityFallbackBrush");
|
|
|
|
UBackgroundBlur_SetLowQualityFallbackBrush_Params params;
|
|
params.InBrush = InBrush;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.BackgroundBlur.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBackgroundBlur::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BackgroundBlur.SetHorizontalAlignment");
|
|
|
|
UBackgroundBlur_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.BackgroundBlur.SetBlurStrength
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InStrength (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBackgroundBlur::SetBlurStrength(float InStrength)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BackgroundBlur.SetBlurStrength");
|
|
|
|
UBackgroundBlur_SetBlurStrength_Params params;
|
|
params.InStrength = InStrength;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.BackgroundBlur.SetBlurRadius
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InBlurRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBackgroundBlur::SetBlurRadius(int InBlurRadius)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BackgroundBlur.SetBlurRadius");
|
|
|
|
UBackgroundBlur_SetBlurRadius_Params params;
|
|
params.InBlurRadius = InBlurRadius;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.BackgroundBlur.SetApplyAlphaToBlur
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInApplyAlphaToBlur (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBackgroundBlur::SetApplyAlphaToBlur(bool bInApplyAlphaToBlur)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BackgroundBlur.SetApplyAlphaToBlur");
|
|
|
|
UBackgroundBlur_SetApplyAlphaToBlur_Params params;
|
|
params.bInApplyAlphaToBlur = bInApplyAlphaToBlur;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.BackgroundBlurSlot.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBackgroundBlurSlot::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BackgroundBlurSlot.SetVerticalAlignment");
|
|
|
|
UBackgroundBlurSlot_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.BackgroundBlurSlot.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UBackgroundBlurSlot::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BackgroundBlurSlot.SetPadding");
|
|
|
|
UBackgroundBlurSlot_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.BackgroundBlurSlot.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBackgroundBlurSlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BackgroundBlurSlot.SetHorizontalAlignment");
|
|
|
|
UBackgroundBlurSlot_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.BoolBinding.GetValue
|
|
// (Final, Native, Public, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UBoolBinding::GetValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BoolBinding.GetValue");
|
|
|
|
UBoolBinding_GetValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Border.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBorder::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Border.SetVerticalAlignment");
|
|
|
|
UBorder_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Border.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UBorder::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Border.SetPadding");
|
|
|
|
UBorder_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Border.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBorder::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Border.SetHorizontalAlignment");
|
|
|
|
UBorder_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Border.SetDesiredSizeScale
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D InScale (Parm, IsPlainOldData)
|
|
|
|
void UBorder::SetDesiredSizeScale(const struct FVector2D& InScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Border.SetDesiredSizeScale");
|
|
|
|
UBorder_SetDesiredSizeScale_Params params;
|
|
params.InScale = InScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Border.SetContentColorAndOpacity
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor InContentColorAndOpacity (Parm, IsPlainOldData)
|
|
|
|
void UBorder::SetContentColorAndOpacity(const struct FLinearColor& InContentColorAndOpacity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Border.SetContentColorAndOpacity");
|
|
|
|
UBorder_SetContentColorAndOpacity_Params params;
|
|
params.InContentColorAndOpacity = InContentColorAndOpacity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Border.SetBrushFromTexture
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTexture2D* Texture (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBorder::SetBrushFromTexture(class UTexture2D* Texture)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Border.SetBrushFromTexture");
|
|
|
|
UBorder_SetBrushFromTexture_Params params;
|
|
params.Texture = Texture;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Border.SetBrushFromMaterial
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* Material (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBorder::SetBrushFromMaterial(class UMaterialInterface* Material)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Border.SetBrushFromMaterial");
|
|
|
|
UBorder_SetBrushFromMaterial_Params params;
|
|
params.Material = Material;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Border.SetBrushFromAsset
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USlateBrushAsset* Asset (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBorder::SetBrushFromAsset(class USlateBrushAsset* Asset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Border.SetBrushFromAsset");
|
|
|
|
UBorder_SetBrushFromAsset_Params params;
|
|
params.Asset = Asset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Border.SetBrushColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor InBrushColor (Parm, IsPlainOldData)
|
|
|
|
void UBorder::SetBrushColor(const struct FLinearColor& InBrushColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Border.SetBrushColor");
|
|
|
|
UBorder_SetBrushColor_Params params;
|
|
params.InBrushColor = InBrushColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Border.SetBrush
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSlateBrush InBrush (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UBorder::SetBrush(const struct FSlateBrush& InBrush)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Border.SetBrush");
|
|
|
|
UBorder_SetBrush_Params params;
|
|
params.InBrush = InBrush;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Border.GetDynamicMaterial
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInstanceDynamic* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInstanceDynamic* UBorder::GetDynamicMaterial()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Border.GetDynamicMaterial");
|
|
|
|
UBorder_GetDynamicMaterial_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.BorderSlot.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBorderSlot::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BorderSlot.SetVerticalAlignment");
|
|
|
|
UBorderSlot_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.BorderSlot.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UBorderSlot::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BorderSlot.SetPadding");
|
|
|
|
UBorderSlot_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.BorderSlot.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBorderSlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BorderSlot.SetHorizontalAlignment");
|
|
|
|
UBorderSlot_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.BrushBinding.GetValue
|
|
// (Final, Native, Public, Const)
|
|
// Parameters:
|
|
// struct FSlateBrush ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FSlateBrush UBrushBinding::GetValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.BrushBinding.GetValue");
|
|
|
|
UBrushBinding_GetValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Button.SetTouchMethod
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EButtonTouchMethod> InTouchMethod (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UButton::SetTouchMethod(TEnumAsByte<EButtonTouchMethod> InTouchMethod)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Button.SetTouchMethod");
|
|
|
|
UButton_SetTouchMethod_Params params;
|
|
params.InTouchMethod = InTouchMethod;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Button.SetStyle
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FButtonStyle InStyle (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UButton::SetStyle(const struct FButtonStyle& InStyle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Button.SetStyle");
|
|
|
|
UButton_SetStyle_Params params;
|
|
params.InStyle = InStyle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Button.SetColorAndOpacity
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor InColorAndOpacity (Parm, IsPlainOldData)
|
|
|
|
void UButton::SetColorAndOpacity(const struct FLinearColor& InColorAndOpacity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Button.SetColorAndOpacity");
|
|
|
|
UButton_SetColorAndOpacity_Params params;
|
|
params.InColorAndOpacity = InColorAndOpacity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Button.SetClickMethod
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EButtonClickMethod> InClickMethod (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UButton::SetClickMethod(TEnumAsByte<EButtonClickMethod> InClickMethod)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Button.SetClickMethod");
|
|
|
|
UButton_SetClickMethod_Params params;
|
|
params.InClickMethod = InClickMethod;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Button.SetBackgroundColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor InBackgroundColor (Parm, IsPlainOldData)
|
|
|
|
void UButton::SetBackgroundColor(const struct FLinearColor& InBackgroundColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Button.SetBackgroundColor");
|
|
|
|
UButton_SetBackgroundColor_Params params;
|
|
params.InBackgroundColor = InBackgroundColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Button.IsPressed
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UButton::IsPressed()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Button.IsPressed");
|
|
|
|
UButton_IsPressed_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.ButtonSlot.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UButtonSlot::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ButtonSlot.SetVerticalAlignment");
|
|
|
|
UButtonSlot_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ButtonSlot.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UButtonSlot::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ButtonSlot.SetPadding");
|
|
|
|
UButtonSlot_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ButtonSlot.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UButtonSlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ButtonSlot.SetHorizontalAlignment");
|
|
|
|
UButtonSlot_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanel.AddChildToCanvas
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidget* content (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UCanvasPanelSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UCanvasPanelSlot* UCanvasPanel::AddChildToCanvas(class UWidget* content)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanel.AddChildToCanvas");
|
|
|
|
UCanvasPanel_AddChildToCanvas_Params params;
|
|
params.content = content;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.SetZOrder
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InZOrder (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCanvasPanelSlot::SetZOrder(int InZOrder)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.SetZOrder");
|
|
|
|
UCanvasPanelSlot_SetZOrder_Params params;
|
|
params.InZOrder = InZOrder;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.SetSize
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D InSize (Parm, IsPlainOldData)
|
|
|
|
void UCanvasPanelSlot::SetSize(const struct FVector2D& InSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.SetSize");
|
|
|
|
UCanvasPanelSlot_SetSize_Params params;
|
|
params.InSize = InSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.SetPosition
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D InPosition (Parm, IsPlainOldData)
|
|
|
|
void UCanvasPanelSlot::SetPosition(const struct FVector2D& InPosition)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.SetPosition");
|
|
|
|
UCanvasPanelSlot_SetPosition_Params params;
|
|
params.InPosition = InPosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.SetOffsets
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InOffset (Parm)
|
|
|
|
void UCanvasPanelSlot::SetOffsets(const struct FMargin& InOffset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.SetOffsets");
|
|
|
|
UCanvasPanelSlot_SetOffsets_Params params;
|
|
params.InOffset = InOffset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.SetMinimum
|
|
// (Final, Native, Public, HasDefaults)
|
|
// Parameters:
|
|
// struct FVector2D InMinimumAnchors (Parm, IsPlainOldData)
|
|
|
|
void UCanvasPanelSlot::SetMinimum(const struct FVector2D& InMinimumAnchors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.SetMinimum");
|
|
|
|
UCanvasPanelSlot_SetMinimum_Params params;
|
|
params.InMinimumAnchors = InMinimumAnchors;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.SetMaximum
|
|
// (Final, Native, Public, HasDefaults)
|
|
// Parameters:
|
|
// struct FVector2D InMaximumAnchors (Parm, IsPlainOldData)
|
|
|
|
void UCanvasPanelSlot::SetMaximum(const struct FVector2D& InMaximumAnchors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.SetMaximum");
|
|
|
|
UCanvasPanelSlot_SetMaximum_Params params;
|
|
params.InMaximumAnchors = InMaximumAnchors;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.SetLayout
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnchorData InLayoutData (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UCanvasPanelSlot::SetLayout(const struct FAnchorData& InLayoutData)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.SetLayout");
|
|
|
|
UCanvasPanelSlot_SetLayout_Params params;
|
|
params.InLayoutData = InLayoutData;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.SetAutoSize
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InbAutoSize (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCanvasPanelSlot::SetAutoSize(bool InbAutoSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.SetAutoSize");
|
|
|
|
UCanvasPanelSlot_SetAutoSize_Params params;
|
|
params.InbAutoSize = InbAutoSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.SetAnchors
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnchors InAnchors (Parm)
|
|
|
|
void UCanvasPanelSlot::SetAnchors(const struct FAnchors& InAnchors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.SetAnchors");
|
|
|
|
UCanvasPanelSlot_SetAnchors_Params params;
|
|
params.InAnchors = InAnchors;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.SetAlignment
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D InAlignment (Parm, IsPlainOldData)
|
|
|
|
void UCanvasPanelSlot::SetAlignment(const struct FVector2D& InAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.SetAlignment");
|
|
|
|
UCanvasPanelSlot_SetAlignment_Params params;
|
|
params.InAlignment = InAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.GetZOrder
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UCanvasPanelSlot::GetZOrder()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.GetZOrder");
|
|
|
|
UCanvasPanelSlot_GetZOrder_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.GetSize
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UCanvasPanelSlot::GetSize()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.GetSize");
|
|
|
|
UCanvasPanelSlot_GetSize_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.GetPosition
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UCanvasPanelSlot::GetPosition()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.GetPosition");
|
|
|
|
UCanvasPanelSlot_GetPosition_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.GetOffsets
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FMargin ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FMargin UCanvasPanelSlot::GetOffsets()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.GetOffsets");
|
|
|
|
UCanvasPanelSlot_GetOffsets_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.GetLayout
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FAnchorData ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FAnchorData UCanvasPanelSlot::GetLayout()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.GetLayout");
|
|
|
|
UCanvasPanelSlot_GetLayout_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.GetAutoSize
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UCanvasPanelSlot::GetAutoSize()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.GetAutoSize");
|
|
|
|
UCanvasPanelSlot_GetAutoSize_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.GetAnchors
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FAnchors ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FAnchors UCanvasPanelSlot::GetAnchors()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.GetAnchors");
|
|
|
|
UCanvasPanelSlot_GetAnchors_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.CanvasPanelSlot.GetAlignment
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UCanvasPanelSlot::GetAlignment()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CanvasPanelSlot.GetAlignment");
|
|
|
|
UCanvasPanelSlot_GetAlignment_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.CheckBox.SetIsChecked
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InIsChecked (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheckBox::SetIsChecked(bool InIsChecked)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CheckBox.SetIsChecked");
|
|
|
|
UCheckBox_SetIsChecked_Params params;
|
|
params.InIsChecked = InIsChecked;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CheckBox.SetCheckedState
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// ECheckBoxState InCheckedState (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheckBox::SetCheckedState(ECheckBoxState InCheckedState)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CheckBox.SetCheckedState");
|
|
|
|
UCheckBox_SetCheckedState_Params params;
|
|
params.InCheckedState = InCheckedState;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CheckBox.IsPressed
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UCheckBox::IsPressed()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CheckBox.IsPressed");
|
|
|
|
UCheckBox_IsPressed_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.CheckBox.IsChecked
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UCheckBox::IsChecked()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CheckBox.IsChecked");
|
|
|
|
UCheckBox_IsChecked_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.CheckBox.GetCheckedState
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// ECheckBoxState ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
ECheckBoxState UCheckBox::GetCheckedState()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CheckBox.GetCheckedState");
|
|
|
|
UCheckBox_GetCheckedState_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.CheckedStateBinding.GetValue
|
|
// (Final, Native, Public, Const)
|
|
// Parameters:
|
|
// ECheckBoxState ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
ECheckBoxState UCheckedStateBinding::GetValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CheckedStateBinding.GetValue");
|
|
|
|
UCheckedStateBinding_GetValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.CircularThrobber.SetRadius
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCircularThrobber::SetRadius(float InRadius)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CircularThrobber.SetRadius");
|
|
|
|
UCircularThrobber_SetRadius_Params params;
|
|
params.InRadius = InRadius;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CircularThrobber.SetPeriod
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InPeriod (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCircularThrobber::SetPeriod(float InPeriod)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CircularThrobber.SetPeriod");
|
|
|
|
UCircularThrobber_SetPeriod_Params params;
|
|
params.InPeriod = InPeriod;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.CircularThrobber.SetNumberOfPieces
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InNumberOfPieces (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCircularThrobber::SetNumberOfPieces(int InNumberOfPieces)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.CircularThrobber.SetNumberOfPieces");
|
|
|
|
UCircularThrobber_SetNumberOfPieces_Params params;
|
|
params.InNumberOfPieces = InNumberOfPieces;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ColorBinding.GetSlateValue
|
|
// (Final, Native, Public, Const)
|
|
// Parameters:
|
|
// struct FSlateColor ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FSlateColor UColorBinding::GetSlateValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ColorBinding.GetSlateValue");
|
|
|
|
UColorBinding_GetSlateValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.ColorBinding.GetLinearValue
|
|
// (Final, Native, Public, HasDefaults, Const)
|
|
// Parameters:
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UColorBinding::GetLinearValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ColorBinding.GetLinearValue");
|
|
|
|
UColorBinding_GetLinearValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.ComboBoxString.SetSelectedOption
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString Option (Parm, ZeroConstructor)
|
|
|
|
void UComboBoxString::SetSelectedOption(const struct FString& Option)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ComboBoxString.SetSelectedOption");
|
|
|
|
UComboBoxString_SetSelectedOption_Params params;
|
|
params.Option = Option;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ComboBoxString.RemoveOption
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString Option (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UComboBoxString::RemoveOption(const struct FString& Option)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ComboBoxString.RemoveOption");
|
|
|
|
UComboBoxString_RemoveOption_Params params;
|
|
params.Option = Option;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.ComboBoxString.RefreshOptions
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UComboBoxString::RefreshOptions()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ComboBoxString.RefreshOptions");
|
|
|
|
UComboBoxString_RefreshOptions_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.ComboBoxString.OnSelectionChangedEvent__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate)
|
|
// Parameters:
|
|
// struct FString SelectedItem (Parm, ZeroConstructor)
|
|
// TEnumAsByte<ESelectInfo> SelectionType (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UComboBoxString::OnSelectionChangedEvent__DelegateSignature(const struct FString& SelectedItem, TEnumAsByte<ESelectInfo> SelectionType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.ComboBoxString.OnSelectionChangedEvent__DelegateSignature");
|
|
|
|
UComboBoxString_OnSelectionChangedEvent__DelegateSignature_Params params;
|
|
params.SelectedItem = SelectedItem;
|
|
params.SelectionType = SelectionType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.ComboBoxString.OnOpeningEvent__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate)
|
|
|
|
void UComboBoxString::OnOpeningEvent__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.ComboBoxString.OnOpeningEvent__DelegateSignature");
|
|
|
|
UComboBoxString_OnOpeningEvent__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ComboBoxString.GetSelectedOption
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UComboBoxString::GetSelectedOption()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ComboBoxString.GetSelectedOption");
|
|
|
|
UComboBoxString_GetSelectedOption_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.ComboBoxString.GetOptionCount
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UComboBoxString::GetOptionCount()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ComboBoxString.GetOptionCount");
|
|
|
|
UComboBoxString_GetOptionCount_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.ComboBoxString.GetOptionAtIndex
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UComboBoxString::GetOptionAtIndex(int Index)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ComboBoxString.GetOptionAtIndex");
|
|
|
|
UComboBoxString_GetOptionAtIndex_Params params;
|
|
params.Index = Index;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.ComboBoxString.FindOptionIndex
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FString Option (Parm, ZeroConstructor)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UComboBoxString::FindOptionIndex(const struct FString& Option)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ComboBoxString.FindOptionIndex");
|
|
|
|
UComboBoxString_FindOptionIndex_Params params;
|
|
params.Option = Option;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.ComboBoxString.ClearSelection
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UComboBoxString::ClearSelection()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ComboBoxString.ClearSelection");
|
|
|
|
UComboBoxString_ClearSelection_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ComboBoxString.ClearOptions
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UComboBoxString::ClearOptions()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ComboBoxString.ClearOptions");
|
|
|
|
UComboBoxString_ClearOptions_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ComboBoxString.AddOption
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString Option (Parm, ZeroConstructor)
|
|
|
|
void UComboBoxString::AddOption(const struct FString& Option)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ComboBoxString.AddOption");
|
|
|
|
UComboBoxString_AddOption_Params params;
|
|
params.Option = Option;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.DragDropOperation.Drop
|
|
// (Native, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FPointerEvent PointerEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UDragDropOperation::Drop(const struct FPointerEvent& PointerEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.DragDropOperation.Drop");
|
|
|
|
UDragDropOperation_Drop_Params params;
|
|
params.PointerEvent = PointerEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.DragDropOperation.Dragged
|
|
// (Native, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FPointerEvent PointerEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UDragDropOperation::Dragged(const struct FPointerEvent& PointerEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.DragDropOperation.Dragged");
|
|
|
|
UDragDropOperation_Dragged_Params params;
|
|
params.PointerEvent = PointerEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.DragDropOperation.DragCancelled
|
|
// (Native, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FPointerEvent PointerEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UDragDropOperation::DragCancelled(const struct FPointerEvent& PointerEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.DragDropOperation.DragCancelled");
|
|
|
|
UDragDropOperation_DragCancelled_Params params;
|
|
params.PointerEvent = PointerEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.EditableText.SetText
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FText InText (Parm)
|
|
|
|
void UEditableText::SetText(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.EditableText.SetText");
|
|
|
|
UEditableText_SetText_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.EditableText.SetIsReadOnly
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InbIsReadyOnly (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UEditableText::SetIsReadOnly(bool InbIsReadyOnly)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.EditableText.SetIsReadOnly");
|
|
|
|
UEditableText_SetIsReadOnly_Params params;
|
|
params.InbIsReadyOnly = InbIsReadyOnly;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.EditableText.SetIsPassword
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InbIsPassword (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UEditableText::SetIsPassword(bool InbIsPassword)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.EditableText.SetIsPassword");
|
|
|
|
UEditableText_SetIsPassword_Params params;
|
|
params.InbIsPassword = InbIsPassword;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.EditableText.SetHintText
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FText InHintText (Parm)
|
|
|
|
void UEditableText::SetHintText(const struct FText& InHintText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.EditableText.SetHintText");
|
|
|
|
UEditableText_SetHintText_Params params;
|
|
params.InHintText = InHintText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.EditableText.OnEditableTextCommittedEvent__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FText Text (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// TEnumAsByte<ETextCommit> CommitMethod (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UEditableText::OnEditableTextCommittedEvent__DelegateSignature(const struct FText& Text, TEnumAsByte<ETextCommit> CommitMethod)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.EditableText.OnEditableTextCommittedEvent__DelegateSignature");
|
|
|
|
UEditableText_OnEditableTextCommittedEvent__DelegateSignature_Params params;
|
|
params.Text = Text;
|
|
params.CommitMethod = CommitMethod;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.EditableText.OnEditableTextChangedEvent__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FText Text (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UEditableText::OnEditableTextChangedEvent__DelegateSignature(const struct FText& Text)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.EditableText.OnEditableTextChangedEvent__DelegateSignature");
|
|
|
|
UEditableText_OnEditableTextChangedEvent__DelegateSignature_Params params;
|
|
params.Text = Text;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.EditableText.GetText
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UEditableText::GetText()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.EditableText.GetText");
|
|
|
|
UEditableText_GetText_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.EditableTextBox.SetText
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FText InText (Parm)
|
|
|
|
void UEditableTextBox::SetText(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.EditableTextBox.SetText");
|
|
|
|
UEditableTextBox_SetText_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.EditableTextBox.SetIsReadOnly
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bReadOnly (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UEditableTextBox::SetIsReadOnly(bool bReadOnly)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.EditableTextBox.SetIsReadOnly");
|
|
|
|
UEditableTextBox_SetIsReadOnly_Params params;
|
|
params.bReadOnly = bReadOnly;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.EditableTextBox.SetHintText
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FText InText (Parm)
|
|
|
|
void UEditableTextBox::SetHintText(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.EditableTextBox.SetHintText");
|
|
|
|
UEditableTextBox_SetHintText_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.EditableTextBox.SetError
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FText InError (Parm)
|
|
|
|
void UEditableTextBox::SetError(const struct FText& InError)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.EditableTextBox.SetError");
|
|
|
|
UEditableTextBox_SetError_Params params;
|
|
params.InError = InError;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.EditableTextBox.OnEditableTextBoxCommittedEvent__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FText Text (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// TEnumAsByte<ETextCommit> CommitMethod (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UEditableTextBox::OnEditableTextBoxCommittedEvent__DelegateSignature(const struct FText& Text, TEnumAsByte<ETextCommit> CommitMethod)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.EditableTextBox.OnEditableTextBoxCommittedEvent__DelegateSignature");
|
|
|
|
UEditableTextBox_OnEditableTextBoxCommittedEvent__DelegateSignature_Params params;
|
|
params.Text = Text;
|
|
params.CommitMethod = CommitMethod;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.EditableTextBox.OnEditableTextBoxChangedEvent__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FText Text (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UEditableTextBox::OnEditableTextBoxChangedEvent__DelegateSignature(const struct FText& Text)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.EditableTextBox.OnEditableTextBoxChangedEvent__DelegateSignature");
|
|
|
|
UEditableTextBox_OnEditableTextBoxChangedEvent__DelegateSignature_Params params;
|
|
params.Text = Text;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.EditableTextBox.HasError
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UEditableTextBox::HasError()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.EditableTextBox.HasError");
|
|
|
|
UEditableTextBox_HasError_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.EditableTextBox.GetText
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UEditableTextBox::GetText()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.EditableTextBox.GetText");
|
|
|
|
UEditableTextBox_GetText_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.EditableTextBox.ClearError
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UEditableTextBox::ClearError()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.EditableTextBox.ClearError");
|
|
|
|
UEditableTextBox_ClearError_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ExpandableArea.SetIsExpanded_Animated
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool IsExpanded (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExpandableArea::SetIsExpanded_Animated(bool IsExpanded)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ExpandableArea.SetIsExpanded_Animated");
|
|
|
|
UExpandableArea_SetIsExpanded_Animated_Params params;
|
|
params.IsExpanded = IsExpanded;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ExpandableArea.SetIsExpanded
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool IsExpanded (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExpandableArea::SetIsExpanded(bool IsExpanded)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ExpandableArea.SetIsExpanded");
|
|
|
|
UExpandableArea_SetIsExpanded_Params params;
|
|
params.IsExpanded = IsExpanded;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ExpandableArea.GetIsExpanded
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UExpandableArea::GetIsExpanded()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ExpandableArea.GetIsExpanded");
|
|
|
|
UExpandableArea_GetIsExpanded_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.FloatBinding.GetValue
|
|
// (Final, Native, Public, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UFloatBinding::GetValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.FloatBinding.GetValue");
|
|
|
|
UFloatBinding_GetValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.GridPanel.SortSlotsByLayerParam
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UGridPanel::SortSlotsByLayerParam()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.GridPanel.SortSlotsByLayerParam");
|
|
|
|
UGridPanel_SortSlotsByLayerParam_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.GridPanel.AddChildToGrid
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidget* content (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UGridSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UGridSlot* UGridPanel::AddChildToGrid(class UWidget* content)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.GridPanel.AddChildToGrid");
|
|
|
|
UGridPanel_AddChildToGrid_Params params;
|
|
params.content = content;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.GridSlot.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGridSlot::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.GridSlot.SetVerticalAlignment");
|
|
|
|
UGridSlot_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.GridSlot.SetRowSpan
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InRowSpan (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGridSlot::SetRowSpan(int InRowSpan)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.GridSlot.SetRowSpan");
|
|
|
|
UGridSlot_SetRowSpan_Params params;
|
|
params.InRowSpan = InRowSpan;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.GridSlot.SetRow
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InRow (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGridSlot::SetRow(int InRow)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.GridSlot.SetRow");
|
|
|
|
UGridSlot_SetRow_Params params;
|
|
params.InRow = InRow;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.GridSlot.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UGridSlot::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.GridSlot.SetPadding");
|
|
|
|
UGridSlot_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.GridSlot.SetLayer
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InLayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGridSlot::SetLayer(int InLayer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.GridSlot.SetLayer");
|
|
|
|
UGridSlot_SetLayer_Params params;
|
|
params.InLayer = InLayer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.GridSlot.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGridSlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.GridSlot.SetHorizontalAlignment");
|
|
|
|
UGridSlot_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.GridSlot.SetColumnSpan
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InColumnSpan (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGridSlot::SetColumnSpan(int InColumnSpan)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.GridSlot.SetColumnSpan");
|
|
|
|
UGridSlot_SetColumnSpan_Params params;
|
|
params.InColumnSpan = InColumnSpan;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.GridSlot.SetColumn
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InColumn (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGridSlot::SetColumn(int InColumn)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.GridSlot.SetColumn");
|
|
|
|
UGridSlot_SetColumn_Params params;
|
|
params.InColumn = InColumn;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.HorizontalBox.AddChildToHorizontalBox
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidget* content (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UHorizontalBoxSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UHorizontalBoxSlot* UHorizontalBox::AddChildToHorizontalBox(class UWidget* content)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.HorizontalBox.AddChildToHorizontalBox");
|
|
|
|
UHorizontalBox_AddChildToHorizontalBox_Params params;
|
|
params.content = content;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.HorizontalBoxSlot.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UHorizontalBoxSlot::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.HorizontalBoxSlot.SetVerticalAlignment");
|
|
|
|
UHorizontalBoxSlot_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.HorizontalBoxSlot.SetSize
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSlateChildSize InSize (Parm)
|
|
|
|
void UHorizontalBoxSlot::SetSize(const struct FSlateChildSize& InSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.HorizontalBoxSlot.SetSize");
|
|
|
|
UHorizontalBoxSlot_SetSize_Params params;
|
|
params.InSize = InSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.HorizontalBoxSlot.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UHorizontalBoxSlot::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.HorizontalBoxSlot.SetPadding");
|
|
|
|
UHorizontalBoxSlot_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.HorizontalBoxSlot.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UHorizontalBoxSlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.HorizontalBoxSlot.SetHorizontalAlignment");
|
|
|
|
UHorizontalBoxSlot_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Image.SetOpacity
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InOpacity (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UImage::SetOpacity(float InOpacity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Image.SetOpacity");
|
|
|
|
UImage_SetOpacity_Params params;
|
|
params.InOpacity = InOpacity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Image.SetColorAndOpacity
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor InColorAndOpacity (Parm, IsPlainOldData)
|
|
|
|
void UImage::SetColorAndOpacity(const struct FLinearColor& InColorAndOpacity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Image.SetColorAndOpacity");
|
|
|
|
UImage_SetColorAndOpacity_Params params;
|
|
params.InColorAndOpacity = InColorAndOpacity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Image.SetBrushFromTextureDynamic
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTexture2DDynamic* Texture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bMatchSize (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UImage::SetBrushFromTextureDynamic(class UTexture2DDynamic* Texture, bool bMatchSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Image.SetBrushFromTextureDynamic");
|
|
|
|
UImage_SetBrushFromTextureDynamic_Params params;
|
|
params.Texture = Texture;
|
|
params.bMatchSize = bMatchSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Image.SetBrushFromTexture
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTexture2D* Texture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bMatchSize (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UImage::SetBrushFromTexture(class UTexture2D* Texture, bool bMatchSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Image.SetBrushFromTexture");
|
|
|
|
UImage_SetBrushFromTexture_Params params;
|
|
params.Texture = Texture;
|
|
params.bMatchSize = bMatchSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Image.SetBrushFromMaterial
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* Material (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UImage::SetBrushFromMaterial(class UMaterialInterface* Material)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Image.SetBrushFromMaterial");
|
|
|
|
UImage_SetBrushFromMaterial_Params params;
|
|
params.Material = Material;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Image.SetBrushFromAsset
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USlateBrushAsset* Asset (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UImage::SetBrushFromAsset(class USlateBrushAsset* Asset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Image.SetBrushFromAsset");
|
|
|
|
UImage_SetBrushFromAsset_Params params;
|
|
params.Asset = Asset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Image.SetBrush
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSlateBrush InBrush (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UImage::SetBrush(const struct FSlateBrush& InBrush)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Image.SetBrush");
|
|
|
|
UImage_SetBrush_Params params;
|
|
params.InBrush = InBrush;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Image.GetDynamicMaterial
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInstanceDynamic* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInstanceDynamic* UImage::GetDynamicMaterial()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Image.GetDynamicMaterial");
|
|
|
|
UImage_GetDynamicMaterial_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.InputKeySelector.SetTextBlockVisibility
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// ESlateVisibility InVisibility (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInputKeySelector::SetTextBlockVisibility(ESlateVisibility InVisibility)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.InputKeySelector.SetTextBlockVisibility");
|
|
|
|
UInputKeySelector_SetTextBlockVisibility_Params params;
|
|
params.InVisibility = InVisibility;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.InputKeySelector.SetSelectedKey
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FInputChord InSelectedKey (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UInputKeySelector::SetSelectedKey(const struct FInputChord& InSelectedKey)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.InputKeySelector.SetSelectedKey");
|
|
|
|
UInputKeySelector_SetSelectedKey_Params params;
|
|
params.InSelectedKey = InSelectedKey;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.InputKeySelector.SetNoKeySpecifiedText
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FText InNoKeySpecifiedText (Parm)
|
|
|
|
void UInputKeySelector::SetNoKeySpecifiedText(const struct FText& InNoKeySpecifiedText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.InputKeySelector.SetNoKeySpecifiedText");
|
|
|
|
UInputKeySelector_SetNoKeySpecifiedText_Params params;
|
|
params.InNoKeySpecifiedText = InNoKeySpecifiedText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.InputKeySelector.SetKeySelectionText
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FText InKeySelectionText (Parm)
|
|
|
|
void UInputKeySelector::SetKeySelectionText(const struct FText& InKeySelectionText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.InputKeySelector.SetKeySelectionText");
|
|
|
|
UInputKeySelector_SetKeySelectionText_Params params;
|
|
params.InKeySelectionText = InKeySelectionText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.InputKeySelector.SetAllowModifierKeys
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInAllowModifierKeys (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInputKeySelector::SetAllowModifierKeys(bool bInAllowModifierKeys)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.InputKeySelector.SetAllowModifierKeys");
|
|
|
|
UInputKeySelector_SetAllowModifierKeys_Params params;
|
|
params.bInAllowModifierKeys = bInAllowModifierKeys;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.InputKeySelector.SetAllowGamepadKeys
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInAllowGamepadKeys (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInputKeySelector::SetAllowGamepadKeys(bool bInAllowGamepadKeys)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.InputKeySelector.SetAllowGamepadKeys");
|
|
|
|
UInputKeySelector_SetAllowGamepadKeys_Params params;
|
|
params.bInAllowGamepadKeys = bInAllowGamepadKeys;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.InputKeySelector.OnKeySelected__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate)
|
|
// Parameters:
|
|
// struct FInputChord SelectedKey (Parm)
|
|
|
|
void UInputKeySelector::OnKeySelected__DelegateSignature(const struct FInputChord& SelectedKey)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.InputKeySelector.OnKeySelected__DelegateSignature");
|
|
|
|
UInputKeySelector_OnKeySelected__DelegateSignature_Params params;
|
|
params.SelectedKey = SelectedKey;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.InputKeySelector.OnIsSelectingKeyChanged__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate)
|
|
|
|
void UInputKeySelector::OnIsSelectingKeyChanged__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.InputKeySelector.OnIsSelectingKeyChanged__DelegateSignature");
|
|
|
|
UInputKeySelector_OnIsSelectingKeyChanged__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.InputKeySelector.GetIsSelectingKey
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UInputKeySelector::GetIsSelectingKey()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.InputKeySelector.GetIsSelectingKey");
|
|
|
|
UInputKeySelector_GetIsSelectingKey_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Int32Binding.GetValue
|
|
// (Final, Native, Public, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UInt32Binding::GetValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Int32Binding.GetValue");
|
|
|
|
UInt32Binding_GetValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.InvalidationBox.SetCanCache
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool CanCache (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInvalidationBox::SetCanCache(bool CanCache)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.InvalidationBox.SetCanCache");
|
|
|
|
UInvalidationBox_SetCanCache_Params params;
|
|
params.CanCache = CanCache;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.InvalidationBox.InvalidateCache
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UInvalidationBox::InvalidateCache()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.InvalidationBox.InvalidateCache");
|
|
|
|
UInvalidationBox_InvalidateCache_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.InvalidationBox.GetCanCache
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UInvalidationBox::GetCanCache()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.InvalidationBox.GetCanCache");
|
|
|
|
UInvalidationBox_GetCanCache_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.MenuAnchor.ToggleOpen
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bFocusOnOpen (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMenuAnchor::ToggleOpen(bool bFocusOnOpen)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MenuAnchor.ToggleOpen");
|
|
|
|
UMenuAnchor_ToggleOpen_Params params;
|
|
params.bFocusOnOpen = bFocusOnOpen;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.MenuAnchor.ShouldOpenDueToClick
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UMenuAnchor::ShouldOpenDueToClick()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MenuAnchor.ShouldOpenDueToClick");
|
|
|
|
UMenuAnchor_ShouldOpenDueToClick_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.MenuAnchor.Open
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bFocusMenu (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMenuAnchor::Open(bool bFocusMenu)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MenuAnchor.Open");
|
|
|
|
UMenuAnchor_Open_Params params;
|
|
params.bFocusMenu = bFocusMenu;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.MenuAnchor.IsOpen
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UMenuAnchor::IsOpen()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MenuAnchor.IsOpen");
|
|
|
|
UMenuAnchor_IsOpen_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.MenuAnchor.HasOpenSubMenus
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UMenuAnchor::HasOpenSubMenus()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MenuAnchor.HasOpenSubMenus");
|
|
|
|
UMenuAnchor_HasOpenSubMenus_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.MenuAnchor.GetMenuPosition
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UMenuAnchor::GetMenuPosition()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MenuAnchor.GetMenuPosition");
|
|
|
|
UMenuAnchor_GetMenuPosition_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.MenuAnchor.Close
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UMenuAnchor::Close()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MenuAnchor.Close");
|
|
|
|
UMenuAnchor_Close_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.MouseCursorBinding.GetValue
|
|
// (Final, Native, Public, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<EMouseCursor> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<EMouseCursor> UMouseCursorBinding::GetValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MouseCursorBinding.GetValue");
|
|
|
|
UMouseCursorBinding_GetValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.MultiLineEditableText.SetText
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FText InText (Parm)
|
|
|
|
void UMultiLineEditableText::SetText(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MultiLineEditableText.SetText");
|
|
|
|
UMultiLineEditableText_SetText_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.MultiLineEditableText.SetIsReadOnly
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bReadOnly (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMultiLineEditableText::SetIsReadOnly(bool bReadOnly)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MultiLineEditableText.SetIsReadOnly");
|
|
|
|
UMultiLineEditableText_SetIsReadOnly_Params params;
|
|
params.bReadOnly = bReadOnly;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.MultiLineEditableText.OnMultiLineEditableTextCommittedEvent__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FText Text (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// TEnumAsByte<ETextCommit> CommitMethod (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMultiLineEditableText::OnMultiLineEditableTextCommittedEvent__DelegateSignature(const struct FText& Text, TEnumAsByte<ETextCommit> CommitMethod)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.MultiLineEditableText.OnMultiLineEditableTextCommittedEvent__DelegateSignature");
|
|
|
|
UMultiLineEditableText_OnMultiLineEditableTextCommittedEvent__DelegateSignature_Params params;
|
|
params.Text = Text;
|
|
params.CommitMethod = CommitMethod;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.MultiLineEditableText.OnMultiLineEditableTextChangedEvent__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FText Text (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UMultiLineEditableText::OnMultiLineEditableTextChangedEvent__DelegateSignature(const struct FText& Text)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.MultiLineEditableText.OnMultiLineEditableTextChangedEvent__DelegateSignature");
|
|
|
|
UMultiLineEditableText_OnMultiLineEditableTextChangedEvent__DelegateSignature_Params params;
|
|
params.Text = Text;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.MultiLineEditableText.GetText
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UMultiLineEditableText::GetText()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MultiLineEditableText.GetText");
|
|
|
|
UMultiLineEditableText_GetText_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.MultiLineEditableTextBox.SetText
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FText InText (Parm)
|
|
|
|
void UMultiLineEditableTextBox::SetText(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MultiLineEditableTextBox.SetText");
|
|
|
|
UMultiLineEditableTextBox_SetText_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.MultiLineEditableTextBox.SetIsReadOnly
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bReadOnly (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMultiLineEditableTextBox::SetIsReadOnly(bool bReadOnly)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MultiLineEditableTextBox.SetIsReadOnly");
|
|
|
|
UMultiLineEditableTextBox_SetIsReadOnly_Params params;
|
|
params.bReadOnly = bReadOnly;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.MultiLineEditableTextBox.SetError
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FText InError (Parm)
|
|
|
|
void UMultiLineEditableTextBox::SetError(const struct FText& InError)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MultiLineEditableTextBox.SetError");
|
|
|
|
UMultiLineEditableTextBox_SetError_Params params;
|
|
params.InError = InError;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.MultiLineEditableTextBox.OnMultiLineEditableTextBoxCommittedEvent__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FText Text (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// TEnumAsByte<ETextCommit> CommitMethod (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMultiLineEditableTextBox::OnMultiLineEditableTextBoxCommittedEvent__DelegateSignature(const struct FText& Text, TEnumAsByte<ETextCommit> CommitMethod)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.MultiLineEditableTextBox.OnMultiLineEditableTextBoxCommittedEvent__DelegateSignature");
|
|
|
|
UMultiLineEditableTextBox_OnMultiLineEditableTextBoxCommittedEvent__DelegateSignature_Params params;
|
|
params.Text = Text;
|
|
params.CommitMethod = CommitMethod;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.MultiLineEditableTextBox.OnMultiLineEditableTextBoxChangedEvent__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FText Text (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UMultiLineEditableTextBox::OnMultiLineEditableTextBoxChangedEvent__DelegateSignature(const struct FText& Text)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.MultiLineEditableTextBox.OnMultiLineEditableTextBoxChangedEvent__DelegateSignature");
|
|
|
|
UMultiLineEditableTextBox_OnMultiLineEditableTextBoxChangedEvent__DelegateSignature_Params params;
|
|
params.Text = Text;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.MultiLineEditableTextBox.GetText
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UMultiLineEditableTextBox::GetText()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.MultiLineEditableTextBox.GetText");
|
|
|
|
UMultiLineEditableTextBox_GetText_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Overlay.AddChildToOverlay
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidget* content (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UOverlaySlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UOverlaySlot* UOverlay::AddChildToOverlay(class UWidget* content)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Overlay.AddChildToOverlay");
|
|
|
|
UOverlay_AddChildToOverlay_Params params;
|
|
params.content = content;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.OverlaySlot.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UOverlaySlot::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.OverlaySlot.SetVerticalAlignment");
|
|
|
|
UOverlaySlot_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.OverlaySlot.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UOverlaySlot::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.OverlaySlot.SetPadding");
|
|
|
|
UOverlaySlot_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.OverlaySlot.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UOverlaySlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.OverlaySlot.SetHorizontalAlignment");
|
|
|
|
UOverlaySlot_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ProgressBar.SetPercent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InPercent (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UProgressBar::SetPercent(float InPercent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ProgressBar.SetPercent");
|
|
|
|
UProgressBar_SetPercent_Params params;
|
|
params.InPercent = InPercent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ProgressBar.SetIsMarquee
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InbIsMarquee (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UProgressBar::SetIsMarquee(bool InbIsMarquee)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ProgressBar.SetIsMarquee");
|
|
|
|
UProgressBar_SetIsMarquee_Params params;
|
|
params.InbIsMarquee = InbIsMarquee;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ProgressBar.SetFillColorAndOpacity
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor InColor (Parm, IsPlainOldData)
|
|
|
|
void UProgressBar::SetFillColorAndOpacity(const struct FLinearColor& InColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ProgressBar.SetFillColorAndOpacity");
|
|
|
|
UProgressBar_SetFillColorAndOpacity_Params params;
|
|
params.InColor = InColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.RetainerBox.SetTextureParameter
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName TextureParameter (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void URetainerBox::SetTextureParameter(const struct FName& TextureParameter)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.RetainerBox.SetTextureParameter");
|
|
|
|
URetainerBox_SetTextureParameter_Params params;
|
|
params.TextureParameter = TextureParameter;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.RetainerBox.SetEffectMaterial
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* EffectMaterial (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void URetainerBox::SetEffectMaterial(class UMaterialInterface* EffectMaterial)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.RetainerBox.SetEffectMaterial");
|
|
|
|
URetainerBox_SetEffectMaterial_Params params;
|
|
params.EffectMaterial = EffectMaterial;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.RetainerBox.RequestRender
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void URetainerBox::RequestRender()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.RetainerBox.RequestRender");
|
|
|
|
URetainerBox_RequestRender_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.RetainerBox.GetEffectMaterial
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UMaterialInstanceDynamic* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInstanceDynamic* URetainerBox::GetEffectMaterial()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.RetainerBox.GetEffectMaterial");
|
|
|
|
URetainerBox_GetEffectMaterial_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.SafeZone.SetSidesToPad
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InPadLeft (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool InPadRight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool InPadTop (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool InPadBottom (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USafeZone::SetSidesToPad(bool InPadLeft, bool InPadRight, bool InPadTop, bool InPadBottom)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SafeZone.SetSidesToPad");
|
|
|
|
USafeZone_SetSidesToPad_Params params;
|
|
params.InPadLeft = InPadLeft;
|
|
params.InPadRight = InPadRight;
|
|
params.InPadTop = InPadTop;
|
|
params.InPadBottom = InPadBottom;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScaleBox.SetUserSpecifiedScale
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InUserSpecifiedScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UScaleBox::SetUserSpecifiedScale(float InUserSpecifiedScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScaleBox.SetUserSpecifiedScale");
|
|
|
|
UScaleBox_SetUserSpecifiedScale_Params params;
|
|
params.InUserSpecifiedScale = InUserSpecifiedScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScaleBox.SetStretchDirection
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EStretchDirection> InStretchDirection (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UScaleBox::SetStretchDirection(TEnumAsByte<EStretchDirection> InStretchDirection)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScaleBox.SetStretchDirection");
|
|
|
|
UScaleBox_SetStretchDirection_Params params;
|
|
params.InStretchDirection = InStretchDirection;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScaleBox.SetStretch
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EStretch> InStretch (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UScaleBox::SetStretch(TEnumAsByte<EStretch> InStretch)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScaleBox.SetStretch");
|
|
|
|
UScaleBox_SetStretch_Params params;
|
|
params.InStretch = InStretch;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScaleBox.SetIgnoreInheritedScale
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInIgnoreInheritedScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UScaleBox::SetIgnoreInheritedScale(bool bInIgnoreInheritedScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScaleBox.SetIgnoreInheritedScale");
|
|
|
|
UScaleBox_SetIgnoreInheritedScale_Params params;
|
|
params.bInIgnoreInheritedScale = bInIgnoreInheritedScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScaleBoxSlot.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UScaleBoxSlot::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScaleBoxSlot.SetVerticalAlignment");
|
|
|
|
UScaleBoxSlot_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScaleBoxSlot.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UScaleBoxSlot::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScaleBoxSlot.SetPadding");
|
|
|
|
UScaleBoxSlot_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScaleBoxSlot.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UScaleBoxSlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScaleBoxSlot.SetHorizontalAlignment");
|
|
|
|
UScaleBoxSlot_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScrollBar.SetState
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InOffsetFraction (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InThumbSizeFraction (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UScrollBar::SetState(float InOffsetFraction, float InThumbSizeFraction)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScrollBar.SetState");
|
|
|
|
UScrollBar_SetState_Params params;
|
|
params.InOffsetFraction = InOffsetFraction;
|
|
params.InThumbSizeFraction = InThumbSizeFraction;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScrollBox.SetScrollOffset
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewScrollOffset (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UScrollBox::SetScrollOffset(float NewScrollOffset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScrollBox.SetScrollOffset");
|
|
|
|
UScrollBox_SetScrollOffset_Params params;
|
|
params.NewScrollOffset = NewScrollOffset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScrollBox.SetScrollBarVisibility
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// ESlateVisibility NewScrollBarVisibility (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UScrollBox::SetScrollBarVisibility(ESlateVisibility NewScrollBarVisibility)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScrollBox.SetScrollBarVisibility");
|
|
|
|
UScrollBox_SetScrollBarVisibility_Params params;
|
|
params.NewScrollBarVisibility = NewScrollBarVisibility;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScrollBox.SetScrollbarThickness
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D NewScrollbarThickness (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UScrollBox::SetScrollbarThickness(const struct FVector2D& NewScrollbarThickness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScrollBox.SetScrollbarThickness");
|
|
|
|
UScrollBox_SetScrollbarThickness_Params params;
|
|
params.NewScrollbarThickness = NewScrollbarThickness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScrollBox.SetOrientation
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EOrientation> NewOrientation (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UScrollBox::SetOrientation(TEnumAsByte<EOrientation> NewOrientation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScrollBox.SetOrientation");
|
|
|
|
UScrollBox_SetOrientation_Params params;
|
|
params.NewOrientation = NewOrientation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScrollBox.SetAlwaysShowScrollbar
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool NewAlwaysShowScrollbar (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UScrollBox::SetAlwaysShowScrollbar(bool NewAlwaysShowScrollbar)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScrollBox.SetAlwaysShowScrollbar");
|
|
|
|
UScrollBox_SetAlwaysShowScrollbar_Params params;
|
|
params.NewAlwaysShowScrollbar = NewAlwaysShowScrollbar;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScrollBox.SetAllowOverscroll
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool NewAllowOverscroll (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UScrollBox::SetAllowOverscroll(bool NewAllowOverscroll)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScrollBox.SetAllowOverscroll");
|
|
|
|
UScrollBox_SetAllowOverscroll_Params params;
|
|
params.NewAllowOverscroll = NewAllowOverscroll;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScrollBox.ScrollWidgetIntoView
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidget* WidgetToFind (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// bool AnimateScroll (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EDescendantScrollDestination ScrollDestination (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UScrollBox::ScrollWidgetIntoView(class UWidget* WidgetToFind, bool AnimateScroll, EDescendantScrollDestination ScrollDestination)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScrollBox.ScrollWidgetIntoView");
|
|
|
|
UScrollBox_ScrollWidgetIntoView_Params params;
|
|
params.WidgetToFind = WidgetToFind;
|
|
params.AnimateScroll = AnimateScroll;
|
|
params.ScrollDestination = ScrollDestination;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScrollBox.ScrollToStart
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UScrollBox::ScrollToStart()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScrollBox.ScrollToStart");
|
|
|
|
UScrollBox_ScrollToStart_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScrollBox.ScrollToEnd
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UScrollBox::ScrollToEnd()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScrollBox.ScrollToEnd");
|
|
|
|
UScrollBox_ScrollToEnd_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScrollBox.GetScrollOffset
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UScrollBox::GetScrollOffset()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScrollBox.GetScrollOffset");
|
|
|
|
UScrollBox_GetScrollOffset_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.ScrollBoxSlot.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UScrollBoxSlot::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScrollBoxSlot.SetPadding");
|
|
|
|
UScrollBoxSlot_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.ScrollBoxSlot.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UScrollBoxSlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.ScrollBoxSlot.SetHorizontalAlignment");
|
|
|
|
UScrollBoxSlot_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBox.SetWidthOverride
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InWidthOverride (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USizeBox::SetWidthOverride(float InWidthOverride)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBox.SetWidthOverride");
|
|
|
|
USizeBox_SetWidthOverride_Params params;
|
|
params.InWidthOverride = InWidthOverride;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBox.SetMinDesiredWidth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InMinDesiredWidth (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USizeBox::SetMinDesiredWidth(float InMinDesiredWidth)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBox.SetMinDesiredWidth");
|
|
|
|
USizeBox_SetMinDesiredWidth_Params params;
|
|
params.InMinDesiredWidth = InMinDesiredWidth;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBox.SetMinDesiredHeight
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InMinDesiredHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USizeBox::SetMinDesiredHeight(float InMinDesiredHeight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBox.SetMinDesiredHeight");
|
|
|
|
USizeBox_SetMinDesiredHeight_Params params;
|
|
params.InMinDesiredHeight = InMinDesiredHeight;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBox.SetMaxDesiredWidth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InMaxDesiredWidth (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USizeBox::SetMaxDesiredWidth(float InMaxDesiredWidth)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBox.SetMaxDesiredWidth");
|
|
|
|
USizeBox_SetMaxDesiredWidth_Params params;
|
|
params.InMaxDesiredWidth = InMaxDesiredWidth;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBox.SetMaxDesiredHeight
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InMaxDesiredHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USizeBox::SetMaxDesiredHeight(float InMaxDesiredHeight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBox.SetMaxDesiredHeight");
|
|
|
|
USizeBox_SetMaxDesiredHeight_Params params;
|
|
params.InMaxDesiredHeight = InMaxDesiredHeight;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBox.SetMaxAspectRatio
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InMaxAspectRatio (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USizeBox::SetMaxAspectRatio(float InMaxAspectRatio)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBox.SetMaxAspectRatio");
|
|
|
|
USizeBox_SetMaxAspectRatio_Params params;
|
|
params.InMaxAspectRatio = InMaxAspectRatio;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBox.SetHeightOverride
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InHeightOverride (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USizeBox::SetHeightOverride(float InHeightOverride)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBox.SetHeightOverride");
|
|
|
|
USizeBox_SetHeightOverride_Params params;
|
|
params.InHeightOverride = InHeightOverride;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBox.ClearWidthOverride
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USizeBox::ClearWidthOverride()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBox.ClearWidthOverride");
|
|
|
|
USizeBox_ClearWidthOverride_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBox.ClearMinDesiredWidth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USizeBox::ClearMinDesiredWidth()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBox.ClearMinDesiredWidth");
|
|
|
|
USizeBox_ClearMinDesiredWidth_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBox.ClearMinDesiredHeight
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USizeBox::ClearMinDesiredHeight()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBox.ClearMinDesiredHeight");
|
|
|
|
USizeBox_ClearMinDesiredHeight_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBox.ClearMaxDesiredWidth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USizeBox::ClearMaxDesiredWidth()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBox.ClearMaxDesiredWidth");
|
|
|
|
USizeBox_ClearMaxDesiredWidth_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBox.ClearMaxDesiredHeight
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USizeBox::ClearMaxDesiredHeight()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBox.ClearMaxDesiredHeight");
|
|
|
|
USizeBox_ClearMaxDesiredHeight_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBox.ClearMaxAspectRatio
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USizeBox::ClearMaxAspectRatio()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBox.ClearMaxAspectRatio");
|
|
|
|
USizeBox_ClearMaxAspectRatio_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBox.ClearHeightOverride
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USizeBox::ClearHeightOverride()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBox.ClearHeightOverride");
|
|
|
|
USizeBox_ClearHeightOverride_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBoxSlot.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USizeBoxSlot::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBoxSlot.SetVerticalAlignment");
|
|
|
|
USizeBoxSlot_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBoxSlot.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void USizeBoxSlot::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBoxSlot.SetPadding");
|
|
|
|
USizeBoxSlot_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SizeBoxSlot.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USizeBoxSlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SizeBoxSlot.SetHorizontalAlignment");
|
|
|
|
USizeBoxSlot_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SlateBlueprintLibrary.ScreenToWidgetLocal
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FGeometry Geometry (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector2D ScreenPosition (Parm, IsPlainOldData)
|
|
// struct FVector2D LocalCoordinate (Parm, OutParm, IsPlainOldData)
|
|
|
|
void USlateBlueprintLibrary::ScreenToWidgetLocal(class UObject* WorldContextObject, const struct FGeometry& Geometry, const struct FVector2D& ScreenPosition, struct FVector2D* LocalCoordinate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SlateBlueprintLibrary.ScreenToWidgetLocal");
|
|
|
|
USlateBlueprintLibrary_ScreenToWidgetLocal_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Geometry = Geometry;
|
|
params.ScreenPosition = ScreenPosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (LocalCoordinate != nullptr)
|
|
*LocalCoordinate = params.LocalCoordinate;
|
|
}
|
|
|
|
|
|
// Function UMG.SlateBlueprintLibrary.ScreenToWidgetAbsolute
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ScreenPosition (Parm, IsPlainOldData)
|
|
// struct FVector2D AbsoluteCoordinate (Parm, OutParm, IsPlainOldData)
|
|
|
|
void USlateBlueprintLibrary::ScreenToWidgetAbsolute(class UObject* WorldContextObject, const struct FVector2D& ScreenPosition, struct FVector2D* AbsoluteCoordinate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SlateBlueprintLibrary.ScreenToWidgetAbsolute");
|
|
|
|
USlateBlueprintLibrary_ScreenToWidgetAbsolute_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.ScreenPosition = ScreenPosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (AbsoluteCoordinate != nullptr)
|
|
*AbsoluteCoordinate = params.AbsoluteCoordinate;
|
|
}
|
|
|
|
|
|
// Function UMG.SlateBlueprintLibrary.ScreenToViewport
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ScreenPosition (Parm, IsPlainOldData)
|
|
// struct FVector2D ViewportPosition (Parm, OutParm, IsPlainOldData)
|
|
|
|
void USlateBlueprintLibrary::ScreenToViewport(class UObject* WorldContextObject, const struct FVector2D& ScreenPosition, struct FVector2D* ViewportPosition)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SlateBlueprintLibrary.ScreenToViewport");
|
|
|
|
USlateBlueprintLibrary_ScreenToViewport_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.ScreenPosition = ScreenPosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (ViewportPosition != nullptr)
|
|
*ViewportPosition = params.ViewportPosition;
|
|
}
|
|
|
|
|
|
// Function UMG.SlateBlueprintLibrary.LocalToViewport
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FGeometry Geometry (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector2D LocalCoordinate (Parm, IsPlainOldData)
|
|
// struct FVector2D PixelPosition (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector2D ViewportPosition (Parm, OutParm, IsPlainOldData)
|
|
|
|
void USlateBlueprintLibrary::LocalToViewport(class UObject* WorldContextObject, const struct FGeometry& Geometry, const struct FVector2D& LocalCoordinate, struct FVector2D* PixelPosition, struct FVector2D* ViewportPosition)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SlateBlueprintLibrary.LocalToViewport");
|
|
|
|
USlateBlueprintLibrary_LocalToViewport_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Geometry = Geometry;
|
|
params.LocalCoordinate = LocalCoordinate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (PixelPosition != nullptr)
|
|
*PixelPosition = params.PixelPosition;
|
|
if (ViewportPosition != nullptr)
|
|
*ViewportPosition = params.ViewportPosition;
|
|
}
|
|
|
|
|
|
// Function UMG.SlateBlueprintLibrary.LocalToAbsolute
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FGeometry Geometry (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector2D LocalCoordinate (Parm, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D USlateBlueprintLibrary::LocalToAbsolute(const struct FGeometry& Geometry, const struct FVector2D& LocalCoordinate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SlateBlueprintLibrary.LocalToAbsolute");
|
|
|
|
USlateBlueprintLibrary_LocalToAbsolute_Params params;
|
|
params.Geometry = Geometry;
|
|
params.LocalCoordinate = LocalCoordinate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.SlateBlueprintLibrary.IsUnderLocation
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FGeometry Geometry (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector2D AbsoluteCoordinate (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USlateBlueprintLibrary::IsUnderLocation(const struct FGeometry& Geometry, const struct FVector2D& AbsoluteCoordinate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SlateBlueprintLibrary.IsUnderLocation");
|
|
|
|
USlateBlueprintLibrary_IsUnderLocation_Params params;
|
|
params.Geometry = Geometry;
|
|
params.AbsoluteCoordinate = AbsoluteCoordinate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.SlateBlueprintLibrary.GetLocalSize
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FGeometry Geometry (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D USlateBlueprintLibrary::GetLocalSize(const struct FGeometry& Geometry)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SlateBlueprintLibrary.GetLocalSize");
|
|
|
|
USlateBlueprintLibrary_GetLocalSize_Params params;
|
|
params.Geometry = Geometry;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.SlateBlueprintLibrary.GetAbsoluteSize
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FGeometry Geometry (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D USlateBlueprintLibrary::GetAbsoluteSize(const struct FGeometry& Geometry)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SlateBlueprintLibrary.GetAbsoluteSize");
|
|
|
|
USlateBlueprintLibrary_GetAbsoluteSize_Params params;
|
|
params.Geometry = Geometry;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.SlateBlueprintLibrary.GetAbsolutePosition
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FGeometry Geometry (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D USlateBlueprintLibrary::GetAbsolutePosition(const struct FGeometry& Geometry)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SlateBlueprintLibrary.GetAbsolutePosition");
|
|
|
|
USlateBlueprintLibrary_GetAbsolutePosition_Params params;
|
|
params.Geometry = Geometry;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.SlateBlueprintLibrary.EqualEqual_SlateBrush
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSlateBrush A (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FSlateBrush B (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USlateBlueprintLibrary::EqualEqual_SlateBrush(const struct FSlateBrush& A, const struct FSlateBrush& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SlateBlueprintLibrary.EqualEqual_SlateBrush");
|
|
|
|
USlateBlueprintLibrary_EqualEqual_SlateBrush_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.SlateBlueprintLibrary.AbsoluteToViewport
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D AbsoluteDesktopCoordinate (Parm, IsPlainOldData)
|
|
// struct FVector2D PixelPosition (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector2D ViewportPosition (Parm, OutParm, IsPlainOldData)
|
|
|
|
void USlateBlueprintLibrary::AbsoluteToViewport(class UObject* WorldContextObject, const struct FVector2D& AbsoluteDesktopCoordinate, struct FVector2D* PixelPosition, struct FVector2D* ViewportPosition)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SlateBlueprintLibrary.AbsoluteToViewport");
|
|
|
|
USlateBlueprintLibrary_AbsoluteToViewport_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.AbsoluteDesktopCoordinate = AbsoluteDesktopCoordinate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (PixelPosition != nullptr)
|
|
*PixelPosition = params.PixelPosition;
|
|
if (ViewportPosition != nullptr)
|
|
*ViewportPosition = params.ViewportPosition;
|
|
}
|
|
|
|
|
|
// Function UMG.SlateBlueprintLibrary.AbsoluteToLocal
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FGeometry Geometry (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector2D AbsoluteCoordinate (Parm, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D USlateBlueprintLibrary::AbsoluteToLocal(const struct FGeometry& Geometry, const struct FVector2D& AbsoluteCoordinate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SlateBlueprintLibrary.AbsoluteToLocal");
|
|
|
|
USlateBlueprintLibrary_AbsoluteToLocal_Params params;
|
|
params.Geometry = Geometry;
|
|
params.AbsoluteCoordinate = AbsoluteCoordinate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Slider.SetValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USlider::SetValue(float InValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Slider.SetValue");
|
|
|
|
USlider_SetValue_Params params;
|
|
params.InValue = InValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Slider.SetStepSize
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USlider::SetStepSize(float InValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Slider.SetStepSize");
|
|
|
|
USlider_SetStepSize_Params params;
|
|
params.InValue = InValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Slider.SetSliderHandleColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor InValue (Parm, IsPlainOldData)
|
|
|
|
void USlider::SetSliderHandleColor(const struct FLinearColor& InValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Slider.SetSliderHandleColor");
|
|
|
|
USlider_SetSliderHandleColor_Params params;
|
|
params.InValue = InValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Slider.SetSliderBarColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor InValue (Parm, IsPlainOldData)
|
|
|
|
void USlider::SetSliderBarColor(const struct FLinearColor& InValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Slider.SetSliderBarColor");
|
|
|
|
USlider_SetSliderBarColor_Params params;
|
|
params.InValue = InValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Slider.SetLocked
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USlider::SetLocked(bool InValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Slider.SetLocked");
|
|
|
|
USlider_SetLocked_Params params;
|
|
params.InValue = InValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Slider.SetIndentHandle
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USlider::SetIndentHandle(bool InValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Slider.SetIndentHandle");
|
|
|
|
USlider_SetIndentHandle_Params params;
|
|
params.InValue = InValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Slider.GetValue
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USlider::GetValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Slider.GetValue");
|
|
|
|
USlider_GetValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Spacer.SetSize
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D InSize (Parm, IsPlainOldData)
|
|
|
|
void USpacer::SetSize(const struct FVector2D& InSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Spacer.SetSize");
|
|
|
|
USpacer_SetSize_Params params;
|
|
params.InSize = InSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.SetValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USpinBox::SetValue(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.SetValue");
|
|
|
|
USpinBox_SetValue_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.SetMinValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USpinBox::SetMinValue(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.SetMinValue");
|
|
|
|
USpinBox_SetMinValue_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.SetMinSliderValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USpinBox::SetMinSliderValue(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.SetMinSliderValue");
|
|
|
|
USpinBox_SetMinSliderValue_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.SetMaxValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USpinBox::SetMaxValue(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.SetMaxValue");
|
|
|
|
USpinBox_SetMaxValue_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.SetMaxSliderValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USpinBox::SetMaxSliderValue(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.SetMaxSliderValue");
|
|
|
|
USpinBox_SetMaxSliderValue_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.SetForegroundColor
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSlateColor InForegroundColor (Parm)
|
|
|
|
void USpinBox::SetForegroundColor(const struct FSlateColor& InForegroundColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.SetForegroundColor");
|
|
|
|
USpinBox_SetForegroundColor_Params params;
|
|
params.InForegroundColor = InForegroundColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.SpinBox.OnSpinBoxValueCommittedEvent__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate)
|
|
// Parameters:
|
|
// float InValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ETextCommit> CommitMethod (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USpinBox::OnSpinBoxValueCommittedEvent__DelegateSignature(float InValue, TEnumAsByte<ETextCommit> CommitMethod)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.SpinBox.OnSpinBoxValueCommittedEvent__DelegateSignature");
|
|
|
|
USpinBox_OnSpinBoxValueCommittedEvent__DelegateSignature_Params params;
|
|
params.InValue = InValue;
|
|
params.CommitMethod = CommitMethod;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.SpinBox.OnSpinBoxValueChangedEvent__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate)
|
|
// Parameters:
|
|
// float InValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USpinBox::OnSpinBoxValueChangedEvent__DelegateSignature(float InValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.SpinBox.OnSpinBoxValueChangedEvent__DelegateSignature");
|
|
|
|
USpinBox_OnSpinBoxValueChangedEvent__DelegateSignature_Params params;
|
|
params.InValue = InValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction UMG.SpinBox.OnSpinBoxBeginSliderMovement__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate)
|
|
|
|
void USpinBox::OnSpinBoxBeginSliderMovement__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction UMG.SpinBox.OnSpinBoxBeginSliderMovement__DelegateSignature");
|
|
|
|
USpinBox_OnSpinBoxBeginSliderMovement__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.GetValue
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USpinBox::GetValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.GetValue");
|
|
|
|
USpinBox_GetValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.GetMinValue
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USpinBox::GetMinValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.GetMinValue");
|
|
|
|
USpinBox_GetMinValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.GetMinSliderValue
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USpinBox::GetMinSliderValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.GetMinSliderValue");
|
|
|
|
USpinBox_GetMinSliderValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.GetMaxValue
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USpinBox::GetMaxValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.GetMaxValue");
|
|
|
|
USpinBox_GetMaxValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.GetMaxSliderValue
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USpinBox::GetMaxSliderValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.GetMaxSliderValue");
|
|
|
|
USpinBox_GetMaxSliderValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.ClearMinValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USpinBox::ClearMinValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.ClearMinValue");
|
|
|
|
USpinBox_ClearMinValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.ClearMinSliderValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USpinBox::ClearMinSliderValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.ClearMinSliderValue");
|
|
|
|
USpinBox_ClearMinSliderValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.ClearMaxValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USpinBox::ClearMaxValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.ClearMaxValue");
|
|
|
|
USpinBox_ClearMaxValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.SpinBox.ClearMaxSliderValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USpinBox::ClearMaxSliderValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.SpinBox.ClearMaxSliderValue");
|
|
|
|
USpinBox_ClearMaxSliderValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.TextBinding.GetTextValue
|
|
// (Final, Native, Public, Const)
|
|
// Parameters:
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UTextBinding::GetTextValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TextBinding.GetTextValue");
|
|
|
|
UTextBinding_GetTextValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.TextBinding.GetStringValue
|
|
// (Final, Native, Public, Const)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UTextBinding::GetStringValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TextBinding.GetStringValue");
|
|
|
|
UTextBinding_GetStringValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.TextBlock.SetVerticalJustification
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ETextVerticalJustify> InJustification (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTextBlock::SetVerticalJustification(TEnumAsByte<ETextVerticalJustify> InJustification)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TextBlock.SetVerticalJustification");
|
|
|
|
UTextBlock_SetVerticalJustification_Params params;
|
|
params.InJustification = InJustification;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.TextBlock.SetText
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FText InText (Parm)
|
|
|
|
void UTextBlock::SetText(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TextBlock.SetText");
|
|
|
|
UTextBlock_SetText_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.TextBlock.SetShadowOffset
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D InShadowOffset (Parm, IsPlainOldData)
|
|
|
|
void UTextBlock::SetShadowOffset(const struct FVector2D& InShadowOffset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TextBlock.SetShadowOffset");
|
|
|
|
UTextBlock_SetShadowOffset_Params params;
|
|
params.InShadowOffset = InShadowOffset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.TextBlock.SetShadowColorAndOpacity
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor InShadowColorAndOpacity (Parm, IsPlainOldData)
|
|
|
|
void UTextBlock::SetShadowColorAndOpacity(const struct FLinearColor& InShadowColorAndOpacity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TextBlock.SetShadowColorAndOpacity");
|
|
|
|
UTextBlock_SetShadowColorAndOpacity_Params params;
|
|
params.InShadowColorAndOpacity = InShadowColorAndOpacity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.TextBlock.SetOpacity
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InOpacity (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTextBlock::SetOpacity(float InOpacity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TextBlock.SetOpacity");
|
|
|
|
UTextBlock_SetOpacity_Params params;
|
|
params.InOpacity = InOpacity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.TextBlock.SetMinDesiredWidth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InMinDesiredWidth (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTextBlock::SetMinDesiredWidth(float InMinDesiredWidth)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TextBlock.SetMinDesiredWidth");
|
|
|
|
UTextBlock_SetMinDesiredWidth_Params params;
|
|
params.InMinDesiredWidth = InMinDesiredWidth;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.TextBlock.SetJustification
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ETextJustify> InJustification (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTextBlock::SetJustification(TEnumAsByte<ETextJustify> InJustification)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TextBlock.SetJustification");
|
|
|
|
UTextBlock_SetJustification_Params params;
|
|
params.InJustification = InJustification;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.TextBlock.SetFont
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSlateFontInfo InFontInfo (Parm)
|
|
|
|
void UTextBlock::SetFont(const struct FSlateFontInfo& InFontInfo)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TextBlock.SetFont");
|
|
|
|
UTextBlock_SetFont_Params params;
|
|
params.InFontInfo = InFontInfo;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.TextBlock.SetColorAndOpacity
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSlateColor InColorAndOpacity (Parm)
|
|
|
|
void UTextBlock::SetColorAndOpacity(const struct FSlateColor& InColorAndOpacity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TextBlock.SetColorAndOpacity");
|
|
|
|
UTextBlock_SetColorAndOpacity_Params params;
|
|
params.InColorAndOpacity = InColorAndOpacity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.TextBlock.GetText
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UTextBlock::GetText()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TextBlock.GetText");
|
|
|
|
UTextBlock_GetText_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Throbber.SetNumberOfPieces
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InNumberOfPieces (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UThrobber::SetNumberOfPieces(int InNumberOfPieces)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Throbber.SetNumberOfPieces");
|
|
|
|
UThrobber_SetNumberOfPieces_Params params;
|
|
params.InNumberOfPieces = InNumberOfPieces;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Throbber.SetAnimateVertically
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInAnimateVertically (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UThrobber::SetAnimateVertically(bool bInAnimateVertically)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Throbber.SetAnimateVertically");
|
|
|
|
UThrobber_SetAnimateVertically_Params params;
|
|
params.bInAnimateVertically = bInAnimateVertically;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Throbber.SetAnimateOpacity
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInAnimateOpacity (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UThrobber::SetAnimateOpacity(bool bInAnimateOpacity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Throbber.SetAnimateOpacity");
|
|
|
|
UThrobber_SetAnimateOpacity_Params params;
|
|
params.bInAnimateOpacity = bInAnimateOpacity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Throbber.SetAnimateHorizontally
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInAnimateHorizontally (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UThrobber::SetAnimateHorizontally(bool bInAnimateHorizontally)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Throbber.SetAnimateHorizontally");
|
|
|
|
UThrobber_SetAnimateHorizontally_Params params;
|
|
params.bInAnimateHorizontally = bInAnimateHorizontally;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.TileView.SetItemWidth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Width (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTileView::SetItemWidth(float Width)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TileView.SetItemWidth");
|
|
|
|
UTileView_SetItemWidth_Params params;
|
|
params.Width = Width;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.TileView.SetItemHeight
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Height (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTileView::SetItemHeight(float Height)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TileView.SetItemHeight");
|
|
|
|
UTileView_SetItemHeight_Params params;
|
|
params.Height = Height;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.TileView.RequestListRefresh
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UTileView::RequestListRefresh()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.TileView.RequestListRefresh");
|
|
|
|
UTileView_RequestListRefresh_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UniformGridPanel.SetSlotPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InSlotPadding (Parm)
|
|
|
|
void UUniformGridPanel::SetSlotPadding(const struct FMargin& InSlotPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UniformGridPanel.SetSlotPadding");
|
|
|
|
UUniformGridPanel_SetSlotPadding_Params params;
|
|
params.InSlotPadding = InSlotPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UniformGridPanel.SetMinDesiredSlotWidth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InMinDesiredSlotWidth (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUniformGridPanel::SetMinDesiredSlotWidth(float InMinDesiredSlotWidth)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UniformGridPanel.SetMinDesiredSlotWidth");
|
|
|
|
UUniformGridPanel_SetMinDesiredSlotWidth_Params params;
|
|
params.InMinDesiredSlotWidth = InMinDesiredSlotWidth;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UniformGridPanel.SetMinDesiredSlotHeight
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InMinDesiredSlotHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUniformGridPanel::SetMinDesiredSlotHeight(float InMinDesiredSlotHeight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UniformGridPanel.SetMinDesiredSlotHeight");
|
|
|
|
UUniformGridPanel_SetMinDesiredSlotHeight_Params params;
|
|
params.InMinDesiredSlotHeight = InMinDesiredSlotHeight;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UniformGridPanel.AddChildToUniformGrid
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidget* content (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UUniformGridSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UUniformGridSlot* UUniformGridPanel::AddChildToUniformGrid(class UWidget* content)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UniformGridPanel.AddChildToUniformGrid");
|
|
|
|
UUniformGridPanel_AddChildToUniformGrid_Params params;
|
|
params.content = content;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.UniformGridSlot.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUniformGridSlot::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UniformGridSlot.SetVerticalAlignment");
|
|
|
|
UUniformGridSlot_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UniformGridSlot.SetRow
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InRow (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUniformGridSlot::SetRow(int InRow)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UniformGridSlot.SetRow");
|
|
|
|
UUniformGridSlot_SetRow_Params params;
|
|
params.InRow = InRow;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UniformGridSlot.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUniformGridSlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UniformGridSlot.SetHorizontalAlignment");
|
|
|
|
UUniformGridSlot_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.UniformGridSlot.SetColumn
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InColumn (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UUniformGridSlot::SetColumn(int InColumn)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.UniformGridSlot.SetColumn");
|
|
|
|
UUniformGridSlot_SetColumn_Params params;
|
|
params.InColumn = InColumn;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.VerticalBox.AddChildToVerticalBox
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidget* content (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UVerticalBoxSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UVerticalBoxSlot* UVerticalBox::AddChildToVerticalBox(class UWidget* content)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.VerticalBox.AddChildToVerticalBox");
|
|
|
|
UVerticalBox_AddChildToVerticalBox_Params params;
|
|
params.content = content;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.VerticalBoxSlot.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UVerticalBoxSlot::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.VerticalBoxSlot.SetVerticalAlignment");
|
|
|
|
UVerticalBoxSlot_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.VerticalBoxSlot.SetSize
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSlateChildSize InSize (Parm)
|
|
|
|
void UVerticalBoxSlot::SetSize(const struct FSlateChildSize& InSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.VerticalBoxSlot.SetSize");
|
|
|
|
UVerticalBoxSlot_SetSize_Params params;
|
|
params.InSize = InSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.VerticalBoxSlot.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UVerticalBoxSlot::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.VerticalBoxSlot.SetPadding");
|
|
|
|
UVerticalBoxSlot_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.VerticalBoxSlot.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UVerticalBoxSlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.VerticalBoxSlot.SetHorizontalAlignment");
|
|
|
|
UVerticalBoxSlot_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Viewport.Spawn
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* ActorClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* UViewport::Spawn(class UClass* ActorClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Viewport.Spawn");
|
|
|
|
UViewport_Spawn_Params params;
|
|
params.ActorClass = ActorClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Viewport.SetViewRotation
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
|
|
void UViewport::SetViewRotation(const struct FRotator& Rotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Viewport.SetViewRotation");
|
|
|
|
UViewport_SetViewRotation_Params params;
|
|
params.Rotation = Rotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Viewport.SetViewLocation
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
|
|
void UViewport::SetViewLocation(const struct FVector& Location)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Viewport.SetViewLocation");
|
|
|
|
UViewport_SetViewLocation_Params params;
|
|
params.Location = Location;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.Viewport.GetViewRotation
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UViewport::GetViewRotation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Viewport.GetViewRotation");
|
|
|
|
UViewport_GetViewRotation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Viewport.GetViewportWorld
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UWorld* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UWorld* UViewport::GetViewportWorld()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Viewport.GetViewportWorld");
|
|
|
|
UViewport_GetViewportWorld_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.Viewport.GetViewLocation
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UViewport::GetViewLocation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.Viewport.GetViewLocation");
|
|
|
|
UViewport_GetViewLocation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.VisibilityBinding.GetValue
|
|
// (Final, Native, Public, Const)
|
|
// Parameters:
|
|
// ESlateVisibility ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
ESlateVisibility UVisibilityBinding::GetValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.VisibilityBinding.GetValue");
|
|
|
|
UVisibilityBinding_GetValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WeakRefImage.UnloadTextureResource
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UWeakRefImage::UnloadTextureResource()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WeakRefImage.UnloadTextureResource");
|
|
|
|
UWeakRefImage_UnloadTextureResource_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WeakRefImage.LoadTextureResource
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bAsync (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWeakRefImage::LoadTextureResource(bool bAsync)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WeakRefImage.LoadTextureResource");
|
|
|
|
UWeakRefImage_LoadTextureResource_Params params;
|
|
params.bAsync = bAsync;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetAnimation.GetStartTime
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UWidgetAnimation::GetStartTime()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetAnimation.GetStartTime");
|
|
|
|
UWidgetAnimation_GetStartTime_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetAnimation.GetEndTime
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UWidgetAnimation::GetEndTime()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetAnimation.GetEndTime");
|
|
|
|
UWidgetAnimation_GetEndTime_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBinding.GetValue
|
|
// (Final, Native, Public, Const)
|
|
// Parameters:
|
|
// class UWidget* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UWidget* UWidgetBinding::GetValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBinding.GetValue");
|
|
|
|
UWidgetBinding_GetValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.UnlockMouse
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FEventReply Reply (Parm, OutParm, ReferenceParm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidgetBlueprintLibrary::UnlockMouse(struct FEventReply* Reply)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.UnlockMouse");
|
|
|
|
UWidgetBlueprintLibrary_UnlockMouse_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Reply != nullptr)
|
|
*Reply = params.Reply;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.Unhandled
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidgetBlueprintLibrary::Unhandled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.Unhandled");
|
|
|
|
UWidgetBlueprintLibrary_Unhandled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.SetUserFocus
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FEventReply Reply (Parm, OutParm, ReferenceParm)
|
|
// class UWidget* FocusWidget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// bool bInAllUsers (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidgetBlueprintLibrary::SetUserFocus(class UWidget* FocusWidget, bool bInAllUsers, struct FEventReply* Reply)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.SetUserFocus");
|
|
|
|
UWidgetBlueprintLibrary_SetUserFocus_Params params;
|
|
params.FocusWidget = FocusWidget;
|
|
params.bInAllUsers = bInAllUsers;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Reply != nullptr)
|
|
*Reply = params.Reply;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.SetMousePosition
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FEventReply Reply (Parm, OutParm, ReferenceParm)
|
|
// struct FVector2D NewMousePosition (Parm, IsPlainOldData)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidgetBlueprintLibrary::SetMousePosition(const struct FVector2D& NewMousePosition, struct FEventReply* Reply)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.SetMousePosition");
|
|
|
|
UWidgetBlueprintLibrary_SetMousePosition_Params params;
|
|
params.NewMousePosition = NewMousePosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Reply != nullptr)
|
|
*Reply = params.Reply;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.SetInputMode_UIOnlyEx
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* Target (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UWidget* InWidgetToFocus (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// EMouseLockMode InMouseLockMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::SetInputMode_UIOnlyEx(class APlayerController* Target, class UWidget* InWidgetToFocus, EMouseLockMode InMouseLockMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.SetInputMode_UIOnlyEx");
|
|
|
|
UWidgetBlueprintLibrary_SetInputMode_UIOnlyEx_Params params;
|
|
params.Target = Target;
|
|
params.InWidgetToFocus = InWidgetToFocus;
|
|
params.InMouseLockMode = InMouseLockMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.SetInputMode_UIOnly
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* Target (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UWidget* InWidgetToFocus (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// bool bLockMouseToViewport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::SetInputMode_UIOnly(class APlayerController* Target, class UWidget* InWidgetToFocus, bool bLockMouseToViewport)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.SetInputMode_UIOnly");
|
|
|
|
UWidgetBlueprintLibrary_SetInputMode_UIOnly_Params params;
|
|
params.Target = Target;
|
|
params.InWidgetToFocus = InWidgetToFocus;
|
|
params.bLockMouseToViewport = bLockMouseToViewport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.SetInputMode_GameOnly
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* Target (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::SetInputMode_GameOnly(class APlayerController* Target)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.SetInputMode_GameOnly");
|
|
|
|
UWidgetBlueprintLibrary_SetInputMode_GameOnly_Params params;
|
|
params.Target = Target;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.SetInputMode_GameAndUIEx
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* Target (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UWidget* InWidgetToFocus (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// EMouseLockMode InMouseLockMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bHideCursorDuringCapture (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::SetInputMode_GameAndUIEx(class APlayerController* Target, class UWidget* InWidgetToFocus, EMouseLockMode InMouseLockMode, bool bHideCursorDuringCapture)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.SetInputMode_GameAndUIEx");
|
|
|
|
UWidgetBlueprintLibrary_SetInputMode_GameAndUIEx_Params params;
|
|
params.Target = Target;
|
|
params.InWidgetToFocus = InWidgetToFocus;
|
|
params.InMouseLockMode = InMouseLockMode;
|
|
params.bHideCursorDuringCapture = bHideCursorDuringCapture;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.SetInputMode_GameAndUI
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* Target (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UWidget* InWidgetToFocus (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// bool bLockMouseToViewport (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bHideCursorDuringCapture (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::SetInputMode_GameAndUI(class APlayerController* Target, class UWidget* InWidgetToFocus, bool bLockMouseToViewport, bool bHideCursorDuringCapture)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.SetInputMode_GameAndUI");
|
|
|
|
UWidgetBlueprintLibrary_SetInputMode_GameAndUI_Params params;
|
|
params.Target = Target;
|
|
params.InWidgetToFocus = InWidgetToFocus;
|
|
params.bLockMouseToViewport = bLockMouseToViewport;
|
|
params.bHideCursorDuringCapture = bHideCursorDuringCapture;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.SetHardwareCursor
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EMouseCursor> CursorShape (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName CursorName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D HotSpot (Parm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidgetBlueprintLibrary::SetHardwareCursor(class UObject* WorldContextObject, TEnumAsByte<EMouseCursor> CursorShape, const struct FName& CursorName, const struct FVector2D& HotSpot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.SetHardwareCursor");
|
|
|
|
UWidgetBlueprintLibrary_SetHardwareCursor_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.CursorShape = CursorShape;
|
|
params.CursorName = CursorName;
|
|
params.HotSpot = HotSpot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.SetFocusToGameViewport
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UWidgetBlueprintLibrary::SetFocusToGameViewport()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.SetFocusToGameViewport");
|
|
|
|
UWidgetBlueprintLibrary_SetFocusToGameViewport_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.SetBrushResourceToTexture
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSlateBrush Brush (Parm, OutParm, ReferenceParm)
|
|
// class UTexture2D* Texture (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::SetBrushResourceToTexture(class UTexture2D* Texture, struct FSlateBrush* Brush)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.SetBrushResourceToTexture");
|
|
|
|
UWidgetBlueprintLibrary_SetBrushResourceToTexture_Params params;
|
|
params.Texture = Texture;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Brush != nullptr)
|
|
*Brush = params.Brush;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.SetBrushResourceToMaterial
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSlateBrush Brush (Parm, OutParm, ReferenceParm)
|
|
// class UMaterialInterface* Material (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::SetBrushResourceToMaterial(class UMaterialInterface* Material, struct FSlateBrush* Brush)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.SetBrushResourceToMaterial");
|
|
|
|
UWidgetBlueprintLibrary_SetBrushResourceToMaterial_Params params;
|
|
params.Material = Material;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Brush != nullptr)
|
|
*Brush = params.Brush;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.ReleaseMouseCapture
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FEventReply Reply (Parm, OutParm, ReferenceParm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidgetBlueprintLibrary::ReleaseMouseCapture(struct FEventReply* Reply)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.ReleaseMouseCapture");
|
|
|
|
UWidgetBlueprintLibrary_ReleaseMouseCapture_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Reply != nullptr)
|
|
*Reply = params.Reply;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.ReleaseJoystickCapture
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FEventReply Reply (Parm, OutParm, ReferenceParm)
|
|
// bool bInAllJoysticks (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidgetBlueprintLibrary::ReleaseJoystickCapture(bool bInAllJoysticks, struct FEventReply* Reply)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.ReleaseJoystickCapture");
|
|
|
|
UWidgetBlueprintLibrary_ReleaseJoystickCapture_Params params;
|
|
params.bInAllJoysticks = bInAllJoysticks;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Reply != nullptr)
|
|
*Reply = params.Reply;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.NoResourceBrush
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSlateBrush ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FSlateBrush UWidgetBlueprintLibrary::NoResourceBrush()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.NoResourceBrush");
|
|
|
|
UWidgetBlueprintLibrary_NoResourceBrush_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.MakeBrushFromTexture
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UTexture2D* Texture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Width (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Height (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FSlateBrush ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FSlateBrush UWidgetBlueprintLibrary::MakeBrushFromTexture(class UTexture2D* Texture, int Width, int Height)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.MakeBrushFromTexture");
|
|
|
|
UWidgetBlueprintLibrary_MakeBrushFromTexture_Params params;
|
|
params.Texture = Texture;
|
|
params.Width = Width;
|
|
params.Height = Height;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.MakeBrushFromMaterial
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UMaterialInterface* Material (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Width (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Height (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FSlateBrush ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FSlateBrush UWidgetBlueprintLibrary::MakeBrushFromMaterial(class UMaterialInterface* Material, int Width, int Height)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.MakeBrushFromMaterial");
|
|
|
|
UWidgetBlueprintLibrary_MakeBrushFromMaterial_Params params;
|
|
params.Material = Material;
|
|
params.Width = Width;
|
|
params.Height = Height;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.MakeBrushFromAsset
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class USlateBrushAsset* BrushAsset (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FSlateBrush ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FSlateBrush UWidgetBlueprintLibrary::MakeBrushFromAsset(class USlateBrushAsset* BrushAsset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.MakeBrushFromAsset");
|
|
|
|
UWidgetBlueprintLibrary_MakeBrushFromAsset_Params params;
|
|
params.BrushAsset = BrushAsset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.LockMouse
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FEventReply Reply (Parm, OutParm, ReferenceParm)
|
|
// class UWidget* CapturingWidget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidgetBlueprintLibrary::LockMouse(class UWidget* CapturingWidget, struct FEventReply* Reply)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.LockMouse");
|
|
|
|
UWidgetBlueprintLibrary_LockMouse_Params params;
|
|
params.CapturingWidget = CapturingWidget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Reply != nullptr)
|
|
*Reply = params.Reply;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.IsDragDropping
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidgetBlueprintLibrary::IsDragDropping()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.IsDragDropping");
|
|
|
|
UWidgetBlueprintLibrary_IsDragDropping_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.Handled
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidgetBlueprintLibrary::Handled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.Handled");
|
|
|
|
UWidgetBlueprintLibrary_Handled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.GetSafeZonePadding
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D SafePadding (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector2D SafePaddingScale (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector2D SpillOverPadding (Parm, OutParm, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::GetSafeZonePadding(class UObject* WorldContextObject, struct FVector2D* SafePadding, struct FVector2D* SafePaddingScale, struct FVector2D* SpillOverPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.GetSafeZonePadding");
|
|
|
|
UWidgetBlueprintLibrary_GetSafeZonePadding_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SafePadding != nullptr)
|
|
*SafePadding = params.SafePadding;
|
|
if (SafePaddingScale != nullptr)
|
|
*SafePaddingScale = params.SafePaddingScale;
|
|
if (SpillOverPadding != nullptr)
|
|
*SpillOverPadding = params.SpillOverPadding;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.GetKeyEventFromAnalogInputEvent
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnalogInputEvent Event (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FKeyEvent ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FKeyEvent UWidgetBlueprintLibrary::GetKeyEventFromAnalogInputEvent(const struct FAnalogInputEvent& Event)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.GetKeyEventFromAnalogInputEvent");
|
|
|
|
UWidgetBlueprintLibrary_GetKeyEventFromAnalogInputEvent_Params params;
|
|
params.Event = Event;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.GetInputEventFromPointerEvent
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPointerEvent Event (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FInputEvent ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FInputEvent UWidgetBlueprintLibrary::GetInputEventFromPointerEvent(const struct FPointerEvent& Event)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.GetInputEventFromPointerEvent");
|
|
|
|
UWidgetBlueprintLibrary_GetInputEventFromPointerEvent_Params params;
|
|
params.Event = Event;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.GetInputEventFromNavigationEvent
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FNavigationEvent Event (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FInputEvent ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FInputEvent UWidgetBlueprintLibrary::GetInputEventFromNavigationEvent(const struct FNavigationEvent& Event)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.GetInputEventFromNavigationEvent");
|
|
|
|
UWidgetBlueprintLibrary_GetInputEventFromNavigationEvent_Params params;
|
|
params.Event = Event;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.GetInputEventFromKeyEvent
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FKeyEvent Event (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FInputEvent ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FInputEvent UWidgetBlueprintLibrary::GetInputEventFromKeyEvent(const struct FKeyEvent& Event)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.GetInputEventFromKeyEvent");
|
|
|
|
UWidgetBlueprintLibrary_GetInputEventFromKeyEvent_Params params;
|
|
params.Event = Event;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.GetInputEventFromCharacterEvent
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FCharacterEvent Event (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FInputEvent ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FInputEvent UWidgetBlueprintLibrary::GetInputEventFromCharacterEvent(const struct FCharacterEvent& Event)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.GetInputEventFromCharacterEvent");
|
|
|
|
UWidgetBlueprintLibrary_GetInputEventFromCharacterEvent_Params params;
|
|
params.Event = Event;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.GetDynamicMaterial
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSlateBrush Brush (Parm, OutParm, ReferenceParm)
|
|
// class UMaterialInstanceDynamic* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInstanceDynamic* UWidgetBlueprintLibrary::GetDynamicMaterial(struct FSlateBrush* Brush)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.GetDynamicMaterial");
|
|
|
|
UWidgetBlueprintLibrary_GetDynamicMaterial_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Brush != nullptr)
|
|
*Brush = params.Brush;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.GetDragDroppingContent
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UDragDropOperation* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UDragDropOperation* UWidgetBlueprintLibrary::GetDragDroppingContent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.GetDragDroppingContent");
|
|
|
|
UWidgetBlueprintLibrary_GetDragDroppingContent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.GetBrushResourceAsTexture2D
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSlateBrush Brush (Parm, OutParm, ReferenceParm)
|
|
// class UTexture2D* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UTexture2D* UWidgetBlueprintLibrary::GetBrushResourceAsTexture2D(struct FSlateBrush* Brush)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.GetBrushResourceAsTexture2D");
|
|
|
|
UWidgetBlueprintLibrary_GetBrushResourceAsTexture2D_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Brush != nullptr)
|
|
*Brush = params.Brush;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.GetBrushResourceAsMaterial
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSlateBrush Brush (Parm, OutParm, ReferenceParm)
|
|
// class UMaterialInterface* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInterface* UWidgetBlueprintLibrary::GetBrushResourceAsMaterial(struct FSlateBrush* Brush)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.GetBrushResourceAsMaterial");
|
|
|
|
UWidgetBlueprintLibrary_GetBrushResourceAsMaterial_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Brush != nullptr)
|
|
*Brush = params.Brush;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.GetBrushResource
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSlateBrush Brush (Parm, OutParm, ReferenceParm)
|
|
// class UObject* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UObject* UWidgetBlueprintLibrary::GetBrushResource(struct FSlateBrush* Brush)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.GetBrushResource");
|
|
|
|
UWidgetBlueprintLibrary_GetBrushResource_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Brush != nullptr)
|
|
*Brush = params.Brush;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.GetAllWidgetsWithInterface
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* Interface (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class UUserWidget*> FoundWidgets (Parm, OutParm, ZeroConstructor)
|
|
// bool TopLevelOnly (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::GetAllWidgetsWithInterface(class UObject* WorldContextObject, class UClass* Interface, bool TopLevelOnly, TArray<class UUserWidget*>* FoundWidgets)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.GetAllWidgetsWithInterface");
|
|
|
|
UWidgetBlueprintLibrary_GetAllWidgetsWithInterface_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Interface = Interface;
|
|
params.TopLevelOnly = TopLevelOnly;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (FoundWidgets != nullptr)
|
|
*FoundWidgets = params.FoundWidgets;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.GetAllWidgetsOfClass
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class UUserWidget*> FoundWidgets (Parm, OutParm, ZeroConstructor)
|
|
// class UClass* WidgetClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool TopLevelOnly (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::GetAllWidgetsOfClass(class UObject* WorldContextObject, class UClass* WidgetClass, bool TopLevelOnly, TArray<class UUserWidget*>* FoundWidgets)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.GetAllWidgetsOfClass");
|
|
|
|
UWidgetBlueprintLibrary_GetAllWidgetsOfClass_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.WidgetClass = WidgetClass;
|
|
params.TopLevelOnly = TopLevelOnly;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (FoundWidgets != nullptr)
|
|
*FoundWidgets = params.FoundWidgets;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.EndDragDrop
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FEventReply Reply (Parm, OutParm, ReferenceParm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidgetBlueprintLibrary::EndDragDrop(struct FEventReply* Reply)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.EndDragDrop");
|
|
|
|
UWidgetBlueprintLibrary_EndDragDrop_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Reply != nullptr)
|
|
*Reply = params.Reply;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.DrawTextFormatted
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FPaintContext Context (Parm, OutParm, ReferenceParm)
|
|
// struct FText Text (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FVector2D Position (Parm, IsPlainOldData)
|
|
// class UFont* Font (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int FontSize (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName FontTypeFace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor Tint (Parm, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::DrawTextFormatted(class UFont* Font, const struct FText& Text, const struct FVector2D& Position, const struct FLinearColor& Tint, int FontSize, const struct FName& FontTypeFace, struct FPaintContext* Context)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.DrawTextFormatted");
|
|
|
|
UWidgetBlueprintLibrary_DrawTextFormatted_Params params;
|
|
params.Text = Text;
|
|
params.Position = Position;
|
|
params.Font = Font;
|
|
params.FontSize = FontSize;
|
|
params.FontTypeFace = FontTypeFace;
|
|
params.Tint = Tint;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Context != nullptr)
|
|
*Context = params.Context;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.DrawText
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FPaintContext Context (Parm, OutParm, ReferenceParm)
|
|
// struct FString inString (Parm, ZeroConstructor)
|
|
// struct FVector2D Position (Parm, IsPlainOldData)
|
|
// struct FLinearColor Tint (Parm, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::DrawText(const struct FString& inString, const struct FVector2D& Position, const struct FLinearColor& Tint, struct FPaintContext* Context)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.DrawText");
|
|
|
|
UWidgetBlueprintLibrary_DrawText_Params params;
|
|
params.inString = inString;
|
|
params.Position = Position;
|
|
params.Tint = Tint;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Context != nullptr)
|
|
*Context = params.Context;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.DrawLines
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FPaintContext Context (Parm, OutParm, ReferenceParm)
|
|
// TArray<struct FVector2D> Points (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// struct FLinearColor Tint (Parm, IsPlainOldData)
|
|
// bool bAntiAlias (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::DrawLines(TArray<struct FVector2D> Points, const struct FLinearColor& Tint, bool bAntiAlias, struct FPaintContext* Context)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.DrawLines");
|
|
|
|
UWidgetBlueprintLibrary_DrawLines_Params params;
|
|
params.Points = Points;
|
|
params.Tint = Tint;
|
|
params.bAntiAlias = bAntiAlias;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Context != nullptr)
|
|
*Context = params.Context;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.DrawLine
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FPaintContext Context (Parm, OutParm, ReferenceParm)
|
|
// struct FVector2D PositionA (Parm, IsPlainOldData)
|
|
// struct FVector2D PositionB (Parm, IsPlainOldData)
|
|
// struct FLinearColor Tint (Parm, IsPlainOldData)
|
|
// bool bAntiAlias (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::DrawLine(const struct FVector2D& PositionA, const struct FVector2D& PositionB, const struct FLinearColor& Tint, bool bAntiAlias, struct FPaintContext* Context)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.DrawLine");
|
|
|
|
UWidgetBlueprintLibrary_DrawLine_Params params;
|
|
params.PositionA = PositionA;
|
|
params.PositionB = PositionB;
|
|
params.Tint = Tint;
|
|
params.bAntiAlias = bAntiAlias;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Context != nullptr)
|
|
*Context = params.Context;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.DrawBox
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FPaintContext Context (Parm, OutParm, ReferenceParm)
|
|
// struct FVector2D Position (Parm, IsPlainOldData)
|
|
// struct FVector2D Size (Parm, IsPlainOldData)
|
|
// class USlateBrushAsset* Brush (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor Tint (Parm, IsPlainOldData)
|
|
|
|
void UWidgetBlueprintLibrary::DrawBox(const struct FVector2D& Position, const struct FVector2D& Size, class USlateBrushAsset* Brush, const struct FLinearColor& Tint, struct FPaintContext* Context)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.DrawBox");
|
|
|
|
UWidgetBlueprintLibrary_DrawBox_Params params;
|
|
params.Position = Position;
|
|
params.Size = Size;
|
|
params.Brush = Brush;
|
|
params.Tint = Tint;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Context != nullptr)
|
|
*Context = params.Context;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.DismissAllMenus
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UWidgetBlueprintLibrary::DismissAllMenus()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.DismissAllMenus");
|
|
|
|
UWidgetBlueprintLibrary_DismissAllMenus_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.DetectDragIfPressed
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FPointerEvent PointerEvent (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// class UWidget* WidgetDetectingDrag (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FKey DragKey (Parm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidgetBlueprintLibrary::DetectDragIfPressed(const struct FPointerEvent& PointerEvent, class UWidget* WidgetDetectingDrag, const struct FKey& DragKey)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.DetectDragIfPressed");
|
|
|
|
UWidgetBlueprintLibrary_DetectDragIfPressed_Params params;
|
|
params.PointerEvent = PointerEvent;
|
|
params.WidgetDetectingDrag = WidgetDetectingDrag;
|
|
params.DragKey = DragKey;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.DetectDrag
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FEventReply Reply (Parm, OutParm, ReferenceParm)
|
|
// class UWidget* WidgetDetectingDrag (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FKey DragKey (Parm)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidgetBlueprintLibrary::DetectDrag(class UWidget* WidgetDetectingDrag, const struct FKey& DragKey, struct FEventReply* Reply)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.DetectDrag");
|
|
|
|
UWidgetBlueprintLibrary_DetectDrag_Params params;
|
|
params.WidgetDetectingDrag = WidgetDetectingDrag;
|
|
params.DragKey = DragKey;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Reply != nullptr)
|
|
*Reply = params.Reply;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.CreateDragDropOperation
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* OperationClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UDragDropOperation* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UDragDropOperation* UWidgetBlueprintLibrary::CreateDragDropOperation(class UClass* OperationClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.CreateDragDropOperation");
|
|
|
|
UWidgetBlueprintLibrary_CreateDragDropOperation_Params params;
|
|
params.OperationClass = OperationClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.Create
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* WidgetType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* OwningPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UUserWidget* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UUserWidget* UWidgetBlueprintLibrary::Create(class UObject* WorldContextObject, class UClass* WidgetType, class APlayerController* OwningPlayer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.Create");
|
|
|
|
UWidgetBlueprintLibrary_Create_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.WidgetType = WidgetType;
|
|
params.OwningPlayer = OwningPlayer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.ClearUserFocus
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FEventReply Reply (Parm, OutParm, ReferenceParm)
|
|
// bool bInAllUsers (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidgetBlueprintLibrary::ClearUserFocus(bool bInAllUsers, struct FEventReply* Reply)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.ClearUserFocus");
|
|
|
|
UWidgetBlueprintLibrary_ClearUserFocus_Params params;
|
|
params.bInAllUsers = bInAllUsers;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Reply != nullptr)
|
|
*Reply = params.Reply;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.CaptureMouse
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FEventReply Reply (Parm, OutParm, ReferenceParm)
|
|
// class UWidget* CapturingWidget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidgetBlueprintLibrary::CaptureMouse(class UWidget* CapturingWidget, struct FEventReply* Reply)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.CaptureMouse");
|
|
|
|
UWidgetBlueprintLibrary_CaptureMouse_Params params;
|
|
params.CapturingWidget = CapturingWidget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Reply != nullptr)
|
|
*Reply = params.Reply;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.CaptureJoystick
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FEventReply Reply (Parm, OutParm, ReferenceParm)
|
|
// class UWidget* CapturingWidget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// bool bInAllJoysticks (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FEventReply ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FEventReply UWidgetBlueprintLibrary::CaptureJoystick(class UWidget* CapturingWidget, bool bInAllJoysticks, struct FEventReply* Reply)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.CaptureJoystick");
|
|
|
|
UWidgetBlueprintLibrary_CaptureJoystick_Params params;
|
|
params.CapturingWidget = CapturingWidget;
|
|
params.bInAllJoysticks = bInAllJoysticks;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Reply != nullptr)
|
|
*Reply = params.Reply;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetBlueprintLibrary.CancelDragDrop
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UWidgetBlueprintLibrary::CancelDragDrop()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetBlueprintLibrary.CancelDragDrop");
|
|
|
|
UWidgetBlueprintLibrary_CancelDragDrop_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetComponent.SetWidget
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UUserWidget* Widget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void UWidgetComponent::SetWidget(class UUserWidget* Widget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetComponent.SetWidget");
|
|
|
|
UWidgetComponent_SetWidget_Params params;
|
|
params.Widget = Widget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetComponent.SetTintColorAndOpacity
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor NewTintColorAndOpacity (ConstParm, Parm, IsPlainOldData)
|
|
|
|
void UWidgetComponent::SetTintColorAndOpacity(const struct FLinearColor& NewTintColorAndOpacity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetComponent.SetTintColorAndOpacity");
|
|
|
|
UWidgetComponent_SetTintColorAndOpacity_Params params;
|
|
params.NewTintColorAndOpacity = NewTintColorAndOpacity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetComponent.SetOwnerPlayer
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class ULocalPlayer* LocalPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetComponent::SetOwnerPlayer(class ULocalPlayer* LocalPlayer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetComponent.SetOwnerPlayer");
|
|
|
|
UWidgetComponent_SetOwnerPlayer_Params params;
|
|
params.LocalPlayer = LocalPlayer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetComponent.SetDrawSize
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D Size (Parm, IsPlainOldData)
|
|
|
|
void UWidgetComponent::SetDrawSize(const struct FVector2D& Size)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetComponent.SetDrawSize");
|
|
|
|
UWidgetComponent_SetDrawSize_Params params;
|
|
params.Size = Size;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetComponent.SetBackgroundColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor NewBackgroundColor (ConstParm, Parm, IsPlainOldData)
|
|
|
|
void UWidgetComponent::SetBackgroundColor(const struct FLinearColor& NewBackgroundColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetComponent.SetBackgroundColor");
|
|
|
|
UWidgetComponent_SetBackgroundColor_Params params;
|
|
params.NewBackgroundColor = NewBackgroundColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetComponent.RequestRedraw
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UWidgetComponent::RequestRedraw()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetComponent.RequestRedraw");
|
|
|
|
UWidgetComponent_RequestRedraw_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetComponent.GetUserWidgetObject
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UUserWidget* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UUserWidget* UWidgetComponent::GetUserWidgetObject()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetComponent.GetUserWidgetObject");
|
|
|
|
UWidgetComponent_GetUserWidgetObject_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetComponent.GetRenderTarget
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UTextureRenderTarget2D* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UTextureRenderTarget2D* UWidgetComponent::GetRenderTarget()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetComponent.GetRenderTarget");
|
|
|
|
UWidgetComponent_GetRenderTarget_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetComponent.GetOwnerPlayer
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class ULocalPlayer* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class ULocalPlayer* UWidgetComponent::GetOwnerPlayer()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetComponent.GetOwnerPlayer");
|
|
|
|
UWidgetComponent_GetOwnerPlayer_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetComponent.GetMaterialInstance
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UMaterialInstanceDynamic* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInstanceDynamic* UWidgetComponent::GetMaterialInstance()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetComponent.GetMaterialInstance");
|
|
|
|
UWidgetComponent_GetMaterialInstance_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetComponent.GetDrawSize
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UWidgetComponent::GetDrawSize()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetComponent.GetDrawSize");
|
|
|
|
UWidgetComponent_GetDrawSize_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetInteractionComponent.SetCustomHitResult
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FHitResult HitResult (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UWidgetInteractionComponent::SetCustomHitResult(const struct FHitResult& HitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetInteractionComponent.SetCustomHitResult");
|
|
|
|
UWidgetInteractionComponent_SetCustomHitResult_Params params;
|
|
params.HitResult = HitResult;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetInteractionComponent.SendKeyChar
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString Characters (Parm, ZeroConstructor)
|
|
// bool bRepeat (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidgetInteractionComponent::SendKeyChar(const struct FString& Characters, bool bRepeat)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetInteractionComponent.SendKeyChar");
|
|
|
|
UWidgetInteractionComponent_SendKeyChar_Params params;
|
|
params.Characters = Characters;
|
|
params.bRepeat = bRepeat;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetInteractionComponent.ScrollWheel
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float ScrollDelta (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetInteractionComponent::ScrollWheel(float ScrollDelta)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetInteractionComponent.ScrollWheel");
|
|
|
|
UWidgetInteractionComponent_ScrollWheel_Params params;
|
|
params.ScrollDelta = ScrollDelta;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetInteractionComponent.ReleasePointerKey
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
|
|
void UWidgetInteractionComponent::ReleasePointerKey(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetInteractionComponent.ReleasePointerKey");
|
|
|
|
UWidgetInteractionComponent_ReleasePointerKey_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetInteractionComponent.ReleaseKey
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidgetInteractionComponent::ReleaseKey(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetInteractionComponent.ReleaseKey");
|
|
|
|
UWidgetInteractionComponent_ReleaseKey_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetInteractionComponent.PressPointerKey
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
|
|
void UWidgetInteractionComponent::PressPointerKey(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetInteractionComponent.PressPointerKey");
|
|
|
|
UWidgetInteractionComponent_PressPointerKey_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetInteractionComponent.PressKey
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// bool bRepeat (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidgetInteractionComponent::PressKey(const struct FKey& Key, bool bRepeat)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetInteractionComponent.PressKey");
|
|
|
|
UWidgetInteractionComponent_PressKey_Params params;
|
|
params.Key = Key;
|
|
params.bRepeat = bRepeat;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetInteractionComponent.PressAndReleaseKey
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidgetInteractionComponent::PressAndReleaseKey(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetInteractionComponent.PressAndReleaseKey");
|
|
|
|
UWidgetInteractionComponent_PressAndReleaseKey_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetInteractionComponent.IsOverInteractableWidget
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidgetInteractionComponent::IsOverInteractableWidget()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetInteractionComponent.IsOverInteractableWidget");
|
|
|
|
UWidgetInteractionComponent_IsOverInteractableWidget_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetInteractionComponent.IsOverHitTestVisibleWidget
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidgetInteractionComponent::IsOverHitTestVisibleWidget()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetInteractionComponent.IsOverHitTestVisibleWidget");
|
|
|
|
UWidgetInteractionComponent_IsOverHitTestVisibleWidget_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetInteractionComponent.IsOverFocusableWidget
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidgetInteractionComponent::IsOverFocusableWidget()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetInteractionComponent.IsOverFocusableWidget");
|
|
|
|
UWidgetInteractionComponent_IsOverFocusableWidget_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetInteractionComponent.GetLastHitResult
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FHitResult ReturnValue (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, IsPlainOldData)
|
|
|
|
struct FHitResult UWidgetInteractionComponent::GetLastHitResult()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetInteractionComponent.GetLastHitResult");
|
|
|
|
UWidgetInteractionComponent_GetLastHitResult_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetInteractionComponent.GetHoveredWidgetComponent
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UWidgetComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UWidgetComponent* UWidgetInteractionComponent::GetHoveredWidgetComponent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetInteractionComponent.GetHoveredWidgetComponent");
|
|
|
|
UWidgetInteractionComponent_GetHoveredWidgetComponent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetInteractionComponent.Get2DHitLocation
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UWidgetInteractionComponent::Get2DHitLocation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetInteractionComponent.Get2DHitLocation");
|
|
|
|
UWidgetInteractionComponent_Get2DHitLocation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.SlotAsVerticalBoxSlot
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UWidget* Widget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UVerticalBoxSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UVerticalBoxSlot* UWidgetLayoutLibrary::SlotAsVerticalBoxSlot(class UWidget* Widget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.SlotAsVerticalBoxSlot");
|
|
|
|
UWidgetLayoutLibrary_SlotAsVerticalBoxSlot_Params params;
|
|
params.Widget = Widget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.SlotAsUniformGridSlot
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UWidget* Widget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UUniformGridSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UUniformGridSlot* UWidgetLayoutLibrary::SlotAsUniformGridSlot(class UWidget* Widget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.SlotAsUniformGridSlot");
|
|
|
|
UWidgetLayoutLibrary_SlotAsUniformGridSlot_Params params;
|
|
params.Widget = Widget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.SlotAsOverlaySlot
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UWidget* Widget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UOverlaySlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UOverlaySlot* UWidgetLayoutLibrary::SlotAsOverlaySlot(class UWidget* Widget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.SlotAsOverlaySlot");
|
|
|
|
UWidgetLayoutLibrary_SlotAsOverlaySlot_Params params;
|
|
params.Widget = Widget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.SlotAsHorizontalBoxSlot
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UWidget* Widget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UHorizontalBoxSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UHorizontalBoxSlot* UWidgetLayoutLibrary::SlotAsHorizontalBoxSlot(class UWidget* Widget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.SlotAsHorizontalBoxSlot");
|
|
|
|
UWidgetLayoutLibrary_SlotAsHorizontalBoxSlot_Params params;
|
|
params.Widget = Widget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.SlotAsGridSlot
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UWidget* Widget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UGridSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UGridSlot* UWidgetLayoutLibrary::SlotAsGridSlot(class UWidget* Widget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.SlotAsGridSlot");
|
|
|
|
UWidgetLayoutLibrary_SlotAsGridSlot_Params params;
|
|
params.Widget = Widget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.SlotAsCanvasSlot
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UWidget* Widget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UCanvasPanelSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UCanvasPanelSlot* UWidgetLayoutLibrary::SlotAsCanvasSlot(class UWidget* Widget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.SlotAsCanvasSlot");
|
|
|
|
UWidgetLayoutLibrary_SlotAsCanvasSlot_Params params;
|
|
params.Widget = Widget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.SlotAsBorderSlot
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UWidget* Widget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UBorderSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UBorderSlot* UWidgetLayoutLibrary::SlotAsBorderSlot(class UWidget* Widget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.SlotAsBorderSlot");
|
|
|
|
UWidgetLayoutLibrary_SlotAsBorderSlot_Params params;
|
|
params.Widget = Widget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.RemoveAllWidgets
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetLayoutLibrary::RemoveAllWidgets(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.RemoveAllWidgets");
|
|
|
|
UWidgetLayoutLibrary_RemoveAllWidgets_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.ProjectWorldLocationToWidgetPosition
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector WorldLocation (Parm, IsPlainOldData)
|
|
// struct FVector2D ScreenPosition (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidgetLayoutLibrary::ProjectWorldLocationToWidgetPosition(class APlayerController* PlayerController, const struct FVector& WorldLocation, struct FVector2D* ScreenPosition)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.ProjectWorldLocationToWidgetPosition");
|
|
|
|
UWidgetLayoutLibrary_ProjectWorldLocationToWidgetPosition_Params params;
|
|
params.PlayerController = PlayerController;
|
|
params.WorldLocation = WorldLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (ScreenPosition != nullptr)
|
|
*ScreenPosition = params.ScreenPosition;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.GetViewportWidgetGeometry
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FGeometry ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FGeometry UWidgetLayoutLibrary::GetViewportWidgetGeometry(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.GetViewportWidgetGeometry");
|
|
|
|
UWidgetLayoutLibrary_GetViewportWidgetGeometry_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.GetViewportSize
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UWidgetLayoutLibrary::GetViewportSize(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.GetViewportSize");
|
|
|
|
UWidgetLayoutLibrary_GetViewportSize_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.GetViewportScale
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UWidgetLayoutLibrary::GetViewportScale(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.GetViewportScale");
|
|
|
|
UWidgetLayoutLibrary_GetViewportScale_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.GetPlayerScreenWidgetGeometry
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FGeometry ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FGeometry UWidgetLayoutLibrary::GetPlayerScreenWidgetGeometry(class APlayerController* PlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.GetPlayerScreenWidgetGeometry");
|
|
|
|
UWidgetLayoutLibrary_GetPlayerScreenWidgetGeometry_Params params;
|
|
params.PlayerController = PlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.GetMousePositionScaledByDPI
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class APlayerController* Player (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float LocationX (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float LocationY (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UWidgetLayoutLibrary::GetMousePositionScaledByDPI(class APlayerController* Player, float* LocationX, float* LocationY)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.GetMousePositionScaledByDPI");
|
|
|
|
UWidgetLayoutLibrary_GetMousePositionScaledByDPI_Params params;
|
|
params.Player = Player;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (LocationX != nullptr)
|
|
*LocationX = params.LocationX;
|
|
if (LocationY != nullptr)
|
|
*LocationY = params.LocationY;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.GetMousePositionOnViewport
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UWidgetLayoutLibrary::GetMousePositionOnViewport(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.GetMousePositionOnViewport");
|
|
|
|
UWidgetLayoutLibrary_GetMousePositionOnViewport_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetLayoutLibrary.GetMousePositionOnPlatform
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UWidgetLayoutLibrary::GetMousePositionOnPlatform()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetLayoutLibrary.GetMousePositionOnPlatform");
|
|
|
|
UWidgetLayoutLibrary_GetMousePositionOnPlatform_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetSwitcher.SetActiveWidgetIndex
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetSwitcher::SetActiveWidgetIndex(int Index)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetSwitcher.SetActiveWidgetIndex");
|
|
|
|
UWidgetSwitcher_SetActiveWidgetIndex_Params params;
|
|
params.Index = Index;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetSwitcher.SetActiveWidget
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidget* Widget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void UWidgetSwitcher::SetActiveWidget(class UWidget* Widget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetSwitcher.SetActiveWidget");
|
|
|
|
UWidgetSwitcher_SetActiveWidget_Params params;
|
|
params.Widget = Widget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetSwitcher.GetWidgetAtIndex
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UWidget* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UWidget* UWidgetSwitcher::GetWidgetAtIndex(int Index)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetSwitcher.GetWidgetAtIndex");
|
|
|
|
UWidgetSwitcher_GetWidgetAtIndex_Params params;
|
|
params.Index = Index;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetSwitcher.GetNumWidgets
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UWidgetSwitcher::GetNumWidgets()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetSwitcher.GetNumWidgets");
|
|
|
|
UWidgetSwitcher_GetNumWidgets_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetSwitcher.GetActiveWidgetIndex
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UWidgetSwitcher::GetActiveWidgetIndex()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetSwitcher.GetActiveWidgetIndex");
|
|
|
|
UWidgetSwitcher_GetActiveWidgetIndex_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetSwitcher.GetActiveWidget
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UWidget* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UWidget* UWidgetSwitcher::GetActiveWidget()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetSwitcher.GetActiveWidget");
|
|
|
|
UWidgetSwitcher_GetActiveWidget_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetSwitcherSlot.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetSwitcherSlot::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetSwitcherSlot.SetVerticalAlignment");
|
|
|
|
UWidgetSwitcherSlot_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetSwitcherSlot.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UWidgetSwitcherSlot::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetSwitcherSlot.SetPadding");
|
|
|
|
UWidgetSwitcherSlot_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WidgetSwitcherSlot.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWidgetSwitcherSlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WidgetSwitcherSlot.SetHorizontalAlignment");
|
|
|
|
UWidgetSwitcherSlot_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WindowTitleBarArea.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWindowTitleBarArea::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WindowTitleBarArea.SetVerticalAlignment");
|
|
|
|
UWindowTitleBarArea_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WindowTitleBarArea.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UWindowTitleBarArea::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WindowTitleBarArea.SetPadding");
|
|
|
|
UWindowTitleBarArea_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WindowTitleBarArea.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWindowTitleBarArea::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WindowTitleBarArea.SetHorizontalAlignment");
|
|
|
|
UWindowTitleBarArea_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WindowTitleBarAreaSlot.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWindowTitleBarAreaSlot::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WindowTitleBarAreaSlot.SetVerticalAlignment");
|
|
|
|
UWindowTitleBarAreaSlot_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WindowTitleBarAreaSlot.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UWindowTitleBarAreaSlot::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WindowTitleBarAreaSlot.SetPadding");
|
|
|
|
UWindowTitleBarAreaSlot_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WindowTitleBarAreaSlot.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWindowTitleBarAreaSlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WindowTitleBarAreaSlot.SetHorizontalAlignment");
|
|
|
|
UWindowTitleBarAreaSlot_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WrapBox.SetInnerSlotPadding
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D InPadding (Parm, IsPlainOldData)
|
|
|
|
void UWrapBox::SetInnerSlotPadding(const struct FVector2D& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WrapBox.SetInnerSlotPadding");
|
|
|
|
UWrapBox_SetInnerSlotPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WrapBox.AddChildWrapBox
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UWidget* content (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UWrapBoxSlot* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UWrapBoxSlot* UWrapBox::AddChildWrapBox(class UWidget* content)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WrapBox.AddChildWrapBox");
|
|
|
|
UWrapBox_AddChildWrapBox_Params params;
|
|
params.content = content;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function UMG.WrapBoxSlot.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalAlignment> InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWrapBoxSlot::SetVerticalAlignment(TEnumAsByte<EVerticalAlignment> InVerticalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WrapBoxSlot.SetVerticalAlignment");
|
|
|
|
UWrapBoxSlot_SetVerticalAlignment_Params params;
|
|
params.InVerticalAlignment = InVerticalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WrapBoxSlot.SetPadding
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FMargin InPadding (Parm)
|
|
|
|
void UWrapBoxSlot::SetPadding(const struct FMargin& InPadding)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WrapBoxSlot.SetPadding");
|
|
|
|
UWrapBoxSlot_SetPadding_Params params;
|
|
params.InPadding = InPadding;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WrapBoxSlot.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWrapBoxSlot::SetHorizontalAlignment(TEnumAsByte<EHorizontalAlignment> InHorizontalAlignment)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WrapBoxSlot.SetHorizontalAlignment");
|
|
|
|
UWrapBoxSlot_SetHorizontalAlignment_Params params;
|
|
params.InHorizontalAlignment = InHorizontalAlignment;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WrapBoxSlot.SetFillSpanWhenLessThan
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InFillSpanWhenLessThan (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWrapBoxSlot::SetFillSpanWhenLessThan(float InFillSpanWhenLessThan)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WrapBoxSlot.SetFillSpanWhenLessThan");
|
|
|
|
UWrapBoxSlot_SetFillSpanWhenLessThan_Params params;
|
|
params.InFillSpanWhenLessThan = InFillSpanWhenLessThan;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function UMG.WrapBoxSlot.SetFillEmptySpace
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InbFillEmptySpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWrapBoxSlot::SetFillEmptySpace(bool InbFillEmptySpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function UMG.WrapBoxSlot.SetFillEmptySpace");
|
|
|
|
UWrapBoxSlot_SetFillEmptySpace_Params params;
|
|
params.InbFillEmptySpace = InbFillEmptySpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
}
|
|
|