UCohtmlWidget

More…

#include <CohtmlWidget.h>

Inherits from UWidget

Public Types

	Name
typedef TArray< TWeakObjectPtr< UObject > >	WeakCohUIHoldersArray

Public Functions

	Name
virtual	~UCohtmlWidget()
virtual void	ReleaseSlateResources(bool bReleaseChildren) override
virtual TSharedRef< SWidget >	RebuildWidget() override
virtual void	SynchronizeProperties() override
virtual TSharedPtr< SCohtmlWidget >	CreateSCohtmlWidget()
void	Tick(float DeltaTime)
TSharedPtr< SCohtmlWidget >	GetCoherentWidget()
FORCEINLINE bool	NeedToPaint() const
cohtml::IInputProxy *	GetFocusedInput()
void	SetSoundAttenuation(const FSoundAttenuationSettings & Settings)
void	SetInputPropagationBehaviour(ECohtmlInputPropagationBehaviour::Type Propagation)
ECohtmlInputPropagationBehaviour::Type	GetInputPropagationBehaviour() const
bool	IsReadyToCreateView() const
bool	IsReadyForBindings() const
bool	HasRequestedView() const
void	ShowPaintRects(bool bShow)
void	Load(const FString & Path)
void	Reload()
void	DebugSaveNextFrame()
void	BeginDebugFrameSave()
void	EndDebugFrameSave()
UTextureRenderTarget2D *	GetRenderTexture() const
UCohtmlJSEvent *	CreateJSEvent()
void	TriggerJSEvent(const FString & name, UCohtmlJSEvent * eventData) const
void	RegisterForEvent(UPARAM(DisplayName=“UI Event Name”) FString UIEventName, UPARAM(DisplayName=“Event”) FCohtmlJSEventBPCallback Delegate)
void	RegisterForCustomEvent(UPARAM(DisplayName=“UI Event Name”) const FString & UIEventName, UPARAM(DisplayName=“Custom Event node Owner”) UObject * CustomEventOwner, UPARAM(DisplayName=“Custom Event node Name”) const FString & CustomEventNodeName)
void	CreateDataModelFromObject(const FString & Name, UObject * Model)
void	RemoveDataModelFromObject(UObject * Model)
void	CreateDataModelFromStruct(const FString & Name, const TFieldPath< FStructProperty > Struct)
void	UpdateWholeDataModelFromStruct(const TFieldPath< FStructProperty > Struct) const
void	RemoveDataModelFromStruct(const TFieldPath< FStructProperty > Struct) const
void	UpdateWholeDataModelFromObject(UObject * Model) const
void	SynchronizeModels() const
void	PreloadTextureSync(const FString & AssetPath)
void	PreloadTextureAsync(const FString & AssetPath)
void	AddPreloadedTexture(UTexture2D * Texture)
bool	RemovePreloadedTextureFromPath(const FString & AssetPath)
bool	RemovePreloadedTexture(UTexture2D * Texture)
void	RemoveAllPreloadedTextures()
	DECLARE_FUNCTION(execCreateDataModelFromStruct )
	DECLARE_FUNCTION(execUpdateWholeDataModelFromStruct )
	DECLARE_FUNCTION(execRemoveDataModelFromStruct )
cohtml::View *	GetView() const
virtual void	BeginDestroy() override
virtual bool	IsReadyForFinishDestroy() override
virtual void	FinishDestroy() override
uint32	GetUserIndex()
uint32	GetOwningPlayerID()
void	SetInputFocusToUI()
void	RestoreInputFocusFromUI(bool bForceFocusToGame =false)
void	UpdateLastSavedViewSettings(cohtml::ViewSettings & NewSettings)
FCohtmlCaretRect	GetCaretRect() const
void	SetCaretRect(int x, int y, unsigned width, unsigned height)
cohtml::ECohtmlPageLoadState	GetCurrentPageState() const
TSharedPtr< TCohtmlViewListener< UCohtmlWidget > >	GetViewListener()
WeakCohUIHoldersArray::TIterator	GetCohUIHoldersIterator(UWorld * World)

Public Attributes

	Name
bool	bResetSWidget
TObjectPtr< AActor >	Owner
FCohtmlWidgetTickFunction	WidgetTick
FCohtmlReadyForBindings	ReadyForBindings
FCohtmlScriptingReady	ScriptingReady
FCohtmlBindingsReleased	BindingsReleased
FCohtmlScriptContextCreated	ScriptContextCreated
FCohtmlDOMBuilt	DOMBuilt
FCohtmlFinishLoad	FinishLoad
FCohtmlLoadFailed	LoadFailed
FCohtmlOnNavigateTo	OnNavigateTo
bool	bEnableComplexCSSSupport
TEnumAsByte< enum TextureFilter >	Filter
bool	bReceiveInput
TEnumAsByte< ECohtmlInputPropagationBehaviour::Type >	InputPropagationBehaviour
ECohtmlMultiTouchEventsHandling	MultiTouchEventsHandling
bool	bExecuteCommandProcessingWithLayout
bool	bUseSurfacePartitioning
bool	bRunAdvanceConcurrently
TEnumAsByte< ECohtmlTickGroup >	TickGroup
TArray< TObjectPtr< UTexture2D > >	PreloadedTextures
TArray< CohtmlDelegateFunctorWrapper >	JSEventCallbackWrappers
FString	URL

Protected Attributes

	Name
TSharedPtr< SCohtmlWidget >	CoherentWidget

Friends

	Name
class	TCohtmlViewListener< UCohtmlWidget >

Detailed Description

class UCohtmlWidget;

A HTML5 control powered by Gameface.

Public Types Documentation

typedef WeakCohUIHoldersArray

typedef TArray<TWeakObjectPtr<UObject> > UCohtmlWidget::WeakCohUIHoldersArray;

Public Functions Documentation

function ~UCohtmlWidget

virtual ~UCohtmlWidget()

function ReleaseSlateResources

virtual void ReleaseSlateResources(
    bool bReleaseChildren
) override

function RebuildWidget

virtual TSharedRef< SWidget > RebuildWidget() override

function SynchronizeProperties

virtual void SynchronizeProperties() override

function CreateSCohtmlWidget

virtual TSharedPtr< SCohtmlWidget > CreateSCohtmlWidget()

function Tick

void Tick(
    float DeltaTime
)

function GetCoherentWidget

TSharedPtr< SCohtmlWidget > GetCoherentWidget()

function NeedToPaint

inline FORCEINLINE bool NeedToPaint() const

function GetFocusedInput

cohtml::IInputProxy * GetFocusedInput()

function SetSoundAttenuation

void SetSoundAttenuation(
    const FSoundAttenuationSettings & Settings
)

Sets the AttenuationSettings for the Sound Components Note: Sound is 2D by default. It can be changed to 3D if appropriate AttenuationSettings is set. For more details look at Unreal’s documentation for AttenuationSettings.

function SetInputPropagationBehaviour

void SetInputPropagationBehaviour(
    ECohtmlInputPropagationBehaviour::Type Propagation
)

Sets the type of input that the widget will propagate to the game

function GetInputPropagationBehaviour

ECohtmlInputPropagationBehaviour::Type GetInputPropagationBehaviour() const

Gets the type of input that the widget will propagate to the game

function IsReadyToCreateView

bool IsReadyToCreateView() const

Tells if the View is ready to be created

function IsReadyForBindings

bool IsReadyForBindings() const

Tells if the View is ready for binding operations

function HasRequestedView

bool HasRequestedView() const

Tells if a View has been scheduled for creation

function ShowPaintRects

void ShowPaintRects(
    bool bShow
)

Tells the view to show/hide debug paint rectangles

function Load

void Load(
    const FString & Path
)

Requests a new URL to be loaded in the View

function Reload

void Reload()

Requests the View to reload the current URL

function DebugSaveNextFrame

void DebugSaveNextFrame()

Saves next render frame to disk

function BeginDebugFrameSave

void BeginDebugFrameSave()

Starts saving render frames to disk

function EndDebugFrameSave

void EndDebugFrameSave()

Stops saving render frames to disk

function GetRenderTexture

UTextureRenderTarget2D * GetRenderTexture() const

Gives access to the UI Texture

function CreateJSEvent

UCohtmlJSEvent * CreateJSEvent()

Creates a UI event data that can be used when triggering event in scripting

function TriggerJSEvent

void TriggerJSEvent(
    const FString & name,
    UCohtmlJSEvent * eventData
) const

function RegisterForEvent

void RegisterForEvent(
    UPARAM(DisplayName="UI Event Name") FString UIEventName,
    UPARAM(DisplayName="Event") FCohtmlJSEventBPCallback Delegate
)

You can use this to bind a Blueprint event to an arbitrary scripting event. The Blueprint event must have no parameters. DEPRECATED: This will be removed in future releases in favor of the new RegisterForEvent which works with any Custom Event nodes.

function RegisterForCustomEvent

void RegisterForCustomEvent(
    UPARAM(DisplayName="UI Event Name") const FString & UIEventName,
    UPARAM(DisplayName="Custom Event node Owner") UObject * CustomEventOwner,
    UPARAM(DisplayName="Custom Event node Name") const FString & CustomEventNodeName
)

You can use this to tie a Blueprint Custom Event node to an arbitrary View scripting event.

• Your Blueprint Custom Event node can have any number of parameters as long as they are primitive types, FString, FText, or FName.
• You don’t have to connect the Blueprint Custom Event node itself to anything, the View itself will execute it.

function CreateDataModelFromObject

void CreateDataModelFromObject(
    const FString & Name,
    UObject * Model
)

Creates a global variable (data model) in scripting from an UObject

function RemoveDataModelFromObject

void RemoveDataModelFromObject(
    UObject * Model
)

Removes a global variable (data model) in scripting from a UObject

function CreateDataModelFromStruct

void CreateDataModelFromStruct(
    const FString & Name,
    const TFieldPath< FStructProperty > Struct
)

Creates a global variable (data model) in scripting from a UStruct

function UpdateWholeDataModelFromStruct

void UpdateWholeDataModelFromStruct(
    const TFieldPath< FStructProperty > Struct
) const

Marks a Struct model for update. The UI using this data model will be updated during the next call to SynchronizeModels. For optimum performance, call SynchronizeModels as rarely as possible (e.g. once per frame).

function RemoveDataModelFromStruct

void RemoveDataModelFromStruct(
    const TFieldPath< FStructProperty > Struct
) const

Removes a global variable (data model) in scripting from a UStruct

function UpdateWholeDataModelFromObject

void UpdateWholeDataModelFromObject(
    UObject * Model
) const

Marks an Object model for update. The UI using this data model will be updated during the next call to SynchronizeModels. For optimum performance, call SynchronizeModels as rarely as possible (e.g. once per frame).

function SynchronizeModels

void SynchronizeModels() const

Synchronize all models marked for update.

function PreloadTextureSync

void PreloadTextureSync(
    const FString & AssetPath
)

Loads a Texture Synchronously (BLOCKING the main thread) from asset Path. Once loaded, the Texture will be added to the PreloadedTextures collection. This is useful for ensuring that the requests for UE4 textures will be working over already loaded assets, leading to fast response times.

function PreloadTextureAsync

void PreloadTextureAsync(
    const FString & AssetPath
)

Loads a Texture Asynchronously from asset Path. Once loaded, the Texture will be added to the PreloadedTextures collection. This is useful for ensuring that the requests for UE4 textures will be working over already loaded assets, leading to fast response times.

function AddPreloadedTexture

void AddPreloadedTexture(
    UTexture2D * Texture
)

Adds an already loaded Texture to the PreloadedTextures collection. This is useful for ensuring that the requests for UE4 textures will be working over already loaded assets, leading to fast response times.

function RemovePreloadedTextureFromPath

bool RemovePreloadedTextureFromPath(
    const FString & AssetPath
)

Removes a Texture from the PreloadedTextures collection. This can be used when you no longer need a specific texture inside the collection to be kept loaded, for example after changing URL and View is fully loaded. Note: The removal of elements is an operation with linear complexity, consider using RemoveAllPreloadedTextures instead. Note: Upon destruction of the CohtmlWidget, PreloadedTextures collection will be cleared automatically, so calling this method isn’t mandatory.

function RemovePreloadedTexture

bool RemovePreloadedTexture(
    UTexture2D * Texture
)

Removes all Textures from the PreloadedTextures collection. This can be used when you no longer need any of the textures inside the collection to be kept loaded, for example after changing URL and View is fully loaded. Note: The removal of elements is an operation with linear complexity, consider using RemoveAllPreloadedTextures instead. Note: Upon destruction of the CohtmlWidget, PreloadedTextures collection will be cleared automatically, so calling this method isn’t mandatory.

function RemoveAllPreloadedTextures

void RemoveAllPreloadedTextures()

Removes all Textures from the PreloadedTextures collection. This can be used when you no longer need any of the textures inside the collection to be kept loaded, for example after changing URL and View is fully loaded. Note: Upon destruction of the CohtmlWidget, PreloadedTextures collection will be cleared automatically, so calling this method isn’t mandatory.

function DECLARE_FUNCTION

DECLARE_FUNCTION(
    execCreateDataModelFromStruct
)

function DECLARE_FUNCTION

DECLARE_FUNCTION(
    execUpdateWholeDataModelFromStruct
)

function DECLARE_FUNCTION

DECLARE_FUNCTION(
    execRemoveDataModelFromStruct
)

function GetView

cohtml::View * GetView() const

function BeginDestroy

virtual void BeginDestroy() override

function IsReadyForFinishDestroy

virtual bool IsReadyForFinishDestroy() override

function FinishDestroy

virtual void FinishDestroy() override

function GetUserIndex

uint32 GetUserIndex()

function GetOwningPlayerID

uint32 GetOwningPlayerID()

function SetInputFocusToUI

void SetInputFocusToUI()

function RestoreInputFocusFromUI

void RestoreInputFocusFromUI(
    bool bForceFocusToGame =false
)

function UpdateLastSavedViewSettings

void UpdateLastSavedViewSettings(
    cohtml::ViewSettings & NewSettings
)

function GetCaretRect

FCohtmlCaretRect GetCaretRect() const

function SetCaretRect

void SetCaretRect(
    int x,
    int y,
    unsigned width,
    unsigned height
)

function GetCurrentPageState

cohtml::ECohtmlPageLoadState GetCurrentPageState() const

function GetViewListener

inline TSharedPtr< TCohtmlViewListener< UCohtmlWidget > > GetViewListener()

function GetCohUIHoldersIterator

static WeakCohUIHoldersArray::TIterator GetCohUIHoldersIterator(
    UWorld * World
)

Public Attributes Documentation

variable bResetSWidget

bool bResetSWidget;

If you intend to keep the UWidget alive between level transitions and you want to keep the View alive you should set this to false.

variable Owner

TObjectPtr< AActor > Owner;

Gets or sets the Actor containing any LiveViewComponents.

variable WidgetTick

FCohtmlWidgetTickFunction WidgetTick;

Main tick function for the Widget

variable ReadyForBindings

FCohtmlReadyForBindings ReadyForBindings;

Fired when the View is ready for binding events. Any event bound prior to this will be ignored

variable ScriptingReady

FCohtmlScriptingReady ScriptingReady;

Fired when the View’s document is fully loaded and the “ready for bindings” event has completed

variable BindingsReleased

FCohtmlBindingsReleased BindingsReleased;

Fired when the View has released its bindings

variable ScriptContextCreated

FCohtmlScriptContextCreated ScriptContextCreated;

Called immediately after the View’s script context has been created for the page. This happens before starting to build the DOM.

variable DOMBuilt

FCohtmlDOMBuilt DOMBuilt;

Called when the View’s DOM for the pages is fully constructed, but the referenced resources may not finish loading.

variable FinishLoad

FCohtmlFinishLoad FinishLoad;

Called when a View’s navigation change request failed.

variable LoadFailed

FCohtmlLoadFailed LoadFailed;

Called when the View’s page, including the resources it refers to, is completely loaded and initialized.

variable OnNavigateTo

FCohtmlOnNavigateTo OnNavigateTo;

Called whenever the View is about to navigate to a different URL. You can return false to stop the navigation to the URL.

variable bEnableComplexCSSSupport

bool bEnableComplexCSSSupport;

Whether to enable support for complex CSS selectors (e.g. div > p, div ~ p)

variable Filter

TEnumAsByte< enum TextureFilter > Filter;

variable bReceiveInput

bool bReceiveInput;

Indicates whether input is forwarded to this view

variable InputPropagationBehaviour

TEnumAsByte< ECohtmlInputPropagationBehaviour::Type > InputPropagationBehaviour;

Indicates the type of input this view forwards to the game

variable MultiTouchEventsHandling

ECohtmlMultiTouchEventsHandling MultiTouchEventsHandling;

Indicates whether Touch events (Touch Down, Touch Move and Touch Up) should be gathered and handled by the UI together at the end of the Input frame or separately - one by one. Please note that Multi Touch events handling will have a side effect on the input propagation as we can no longer check whether the UI handles every single touch or not, because events are processed later in bulk.

variable bExecuteCommandProcessingWithLayout

bool bExecuteCommandProcessingWithLayout;

Tells the View to process all collected front-end commands right after the layout execution on the same thread. Note: This option is mandatory when using the Custom Effects and/or the Compositor API features. Note: When this setting is enabled, the rendering library will be used on two different threads: the Game Thread and the Render Thread. Normally the library will detect that but if you have a use case where Game Thread and Rendering tasks are to be executed on the same thread, you’ll have to enable the multithreaded awareness manually by setting LibraryParams::AllowMultithreadedCommandProcessing in the Coherent Rendering plugin to true.

variable bUseSurfacePartitioning

bool bUseSurfacePartitioning;

Enables the Surface Partitioning mode, which does not create a texture for your view, but instead draws separate parts of the HTML in separate small textures. Useful when you have a view with a high resolution that is mostly empty, apart from some content in the corners of the screen that you can draw separately, omitting the big screen texture that you would have otherwise.

variable bRunAdvanceConcurrently

bool bRunAdvanceConcurrently;

When enabled, forces cohtml::View::Advance to be scheduled on background tasks, reducing the load on the game thread. This imposes restrictions on what View operations can be performed on the Game Thread. Please see the documentation for more details.

variable TickGroup

TEnumAsByte< ECohtmlTickGroup > TickGroup;

Sets the tick group in which this component will be ticked and Advance the View. If set to “No tick”, this component will not tick on its own. You are expected to call its Tick function manually from your own code. Useful if you want to control the exact time at which to Advance the View.

variable PreloadedTextures

TArray< TObjectPtr< UTexture2D > > PreloadedTextures;

PreloadedTextures collection, keeping the Textures loaded and ready for use. Ideally, the Textures are to be loaded ahead of time and kept in this collection for ensuring that the requests for UE4 textures will be working over already loaded assets, leading to fast response times.

variable JSEventCallbackWrappers

TArray< CohtmlDelegateFunctorWrapper > JSEventCallbackWrappers;

variable URL

FString URL;

The URL to load when the View is created

Protected Attributes Documentation

variable CoherentWidget

TSharedPtr< SCohtmlWidget > CoherentWidget;

Friends

friend TCohtmlViewListener< UCohtmlWidget >

friend class TCohtmlViewListener< UCohtmlWidget >;

---