//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("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("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("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("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("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("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("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("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("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("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("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("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("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 InCursor (Parm, ZeroConstructor, IsPlainOldData) void UWidget::SetCursor(TEnumAsByte InCursor) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData) TEnumAsByte UWidget::GetMouseCursor__DelegateSignature() { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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 EventType (Parm, ZeroConstructor, IsPlainOldData) void UUserWidget::StopListeningForInputAction(const struct FName& ActionName, TEnumAsByte EventType) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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 PlayMode (Parm, ZeroConstructor, IsPlainOldData) // float PlaybackSpeed (Parm, ZeroConstructor, IsPlainOldData) void UUserWidget::PlayAnimationTo(class UWidgetAnimation* InAnimation, float StartAtTime, float EndAtTime, int NumLoopsToPlay, TEnumAsByte PlayMode, float PlaybackSpeed) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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 PlayMode (Parm, ZeroConstructor, IsPlainOldData) // float PlaybackSpeed (Parm, ZeroConstructor, IsPlainOldData) void UUserWidget::PlayAnimation(class UWidgetAnimation* InAnimation, float StartAtTime, int NumLoopsToPlay, TEnumAsByte PlayMode, float PlaybackSpeed) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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 EventType (Parm, ZeroConstructor, IsPlainOldData) // bool bConsume (Parm, ZeroConstructor, IsPlainOldData) // struct FScriptDelegate Callback (Parm, ZeroConstructor) void UUserWidget::ListenForInputAction(const struct FName& ActionName, TEnumAsByte EventType, bool bConsume, const struct FScriptDelegate& Callback) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UBackgroundBlur::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UBackgroundBlur::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UBackgroundBlurSlot::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UBackgroundBlurSlot::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UBorder::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UBorder::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UBorderSlot::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UBorderSlot::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InTouchMethod (Parm, ZeroConstructor, IsPlainOldData) void UButton::SetTouchMethod(TEnumAsByte InTouchMethod) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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 InClickMethod (Parm, ZeroConstructor, IsPlainOldData) void UButton::SetClickMethod(TEnumAsByte InClickMethod) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UButtonSlot::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UButtonSlot::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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 SelectionType (Parm, ZeroConstructor, IsPlainOldData) void UComboBoxString::OnSelectionChangedEvent__DelegateSignature(const struct FString& SelectedItem, TEnumAsByte SelectionType) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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 CommitMethod (Parm, ZeroConstructor, IsPlainOldData) void UEditableText::OnEditableTextCommittedEvent__DelegateSignature(const struct FText& Text, TEnumAsByte CommitMethod) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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 CommitMethod (Parm, ZeroConstructor, IsPlainOldData) void UEditableTextBox::OnEditableTextBoxCommittedEvent__DelegateSignature(const struct FText& Text, TEnumAsByte CommitMethod) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UGridSlot::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UGridSlot::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UHorizontalBoxSlot::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UHorizontalBoxSlot::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData) TEnumAsByte UMouseCursorBinding::GetValue() { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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 CommitMethod (Parm, ZeroConstructor, IsPlainOldData) void UMultiLineEditableText::OnMultiLineEditableTextCommittedEvent__DelegateSignature(const struct FText& Text, TEnumAsByte CommitMethod) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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 CommitMethod (Parm, ZeroConstructor, IsPlainOldData) void UMultiLineEditableTextBox::OnMultiLineEditableTextBoxCommittedEvent__DelegateSignature(const struct FText& Text, TEnumAsByte CommitMethod) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UOverlaySlot::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UOverlaySlot::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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 InStretchDirection (Parm, ZeroConstructor, IsPlainOldData) void UScaleBox::SetStretchDirection(TEnumAsByte InStretchDirection) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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 InStretch (Parm, ZeroConstructor, IsPlainOldData) void UScaleBox::SetStretch(TEnumAsByte InStretch) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UScaleBoxSlot::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UScaleBoxSlot::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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 NewOrientation (Parm, ZeroConstructor, IsPlainOldData) void UScrollBox::SetOrientation(TEnumAsByte NewOrientation) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UScrollBoxSlot::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void USizeBoxSlot::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void USizeBoxSlot::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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 CommitMethod (Parm, ZeroConstructor, IsPlainOldData) void USpinBox::OnSpinBoxValueCommittedEvent__DelegateSignature(float InValue, TEnumAsByte CommitMethod) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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 InJustification (Parm, ZeroConstructor, IsPlainOldData) void UTextBlock::SetVerticalJustification(TEnumAsByte InJustification) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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 InJustification (Parm, ZeroConstructor, IsPlainOldData) void UTextBlock::SetJustification(TEnumAsByte InJustification) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UUniformGridSlot::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UUniformGridSlot::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UVerticalBoxSlot::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UVerticalBoxSlot::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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 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 CursorShape, const struct FName& CursorName, const struct FVector2D& HotSpot) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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 FoundWidgets (Parm, OutParm, ZeroConstructor) // bool TopLevelOnly (Parm, ZeroConstructor, IsPlainOldData) void UWidgetBlueprintLibrary::GetAllWidgetsWithInterface(class UObject* WorldContextObject, class UClass* Interface, bool TopLevelOnly, TArray* FoundWidgets) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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 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* FoundWidgets) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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 Points (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm) // struct FLinearColor Tint (Parm, IsPlainOldData) // bool bAntiAlias (Parm, ZeroConstructor, IsPlainOldData) void UWidgetBlueprintLibrary::DrawLines(TArray Points, const struct FLinearColor& Tint, bool bAntiAlias, struct FPaintContext* Context) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UWidgetSwitcherSlot::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UWidgetSwitcherSlot::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UWindowTitleBarArea::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UWindowTitleBarArea::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UWindowTitleBarAreaSlot::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UWindowTitleBarAreaSlot::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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 InVerticalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UWrapBoxSlot::SetVerticalAlignment(TEnumAsByte InVerticalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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 InHorizontalAlignment (Parm, ZeroConstructor, IsPlainOldData) void UWrapBoxSlot::SetHorizontalAlignment(TEnumAsByte InHorizontalAlignment) { static UFunction *pFunc = 0; if (!pFunc) pFunc = UObject::FindObject("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("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("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; } }