Engine.UIScreenObject

Extends

UIRoot

Modifiers

native ( UIPrivate ) HideCategories ( Object ) abstract placeable

Base class for all UI entities which can appear onscreen Copyright 1998-2008 Epic Games, Inc. All Rights Reserved.

Core.Object
|   
+-- Engine.UIRoot
   |   
   +-- Engine.UIScreenObject

Direct Known Subclasses:

UIObject, UIScene

Delegates Summary
		NotifyActiveSkinChanged ()
	transient	NotifyActiveStateChanged (UIScreenObject Sender, int PlayerIndex, UIState NewlyActiveState, optional UIState PreviouslyActiveState)
		NotifyPositionChanged (UIScreenObject Sender)
		NotifyResolutionChanged (const out Vector2D OldViewportsize, const out Vector2D NewViewportSize)
		NotifyVisibilityChanged (UIScreenObject SourceWidget, bool bIsVisible)
		OnPreRenderCallBack ()
	bool	OnProcessInputAxis (const out SubscribedInputEventParameters EventParms)
	bool	OnProcessInputKey (const out SubscribedInputEventParameters EventParms)
	bool	OnRawInputAxis (const out InputEventParameters EventParms)
	bool	OnRawInputKey (const out InputEventParameters EventParms)

Functions Summary
	bool	AcceptsPlayerInput (int PlayerIndex ) con)
		ActivateEventByClass (int PlayerIndex, class<UIEvent> EventClassToActivate, optional Object InEventActivator, optional bool bActivateImmediately, optional array<int> IndicesToActivate, optional out array<UIEvent> out_ActivatedEvents)
	bool	ActivateState (UIState StateToActivate, int PlayerIndex)
	bool	ActivateStateByClass (class<UIState> StateToActivate, int PlayerIndex, optional out UIState StateThatWasAdded)
		AddedChild (UIScreenObject WidgetOwner, UIObject NewChild)
	bool	CanAcceptFocus (optional int PlayerIndex=GetBestPlayerIndex() ) con)
	bool	CanPlayOnline (int ControllerId=GetBestControllerId()))
	bool	CanPropagateFocusFor (UIObject TestChild ) con)
	Vector4	CanvasToScreen (const out Vector CanvasPosition ) con)
	bool	ConditionalPropagateEnabledState (int PlayerIndex, optional bool bForce)
	bool	ContainsChild (UIObject Child, optional bool bRecurse=true ) con)
	bool	ContainsChildOfClass (class<UIObject> SearchClass, optional bool bRecurse=true ) con)
		CreatePlayerData (int PlayerIndex, LocalPlayer AddedPlayer)
	UIObject	CreateWidget (UIScreenObject Owner, class<UIObject> WidgetClass, optional Object WidgetArchetype, optional name WidgetName)
	bool	DeactivateState (UIState StateToRemove, int PlayerIndex)
	bool	DeactivateStateByClass (class<UIState> StateToRemove, int PlayerIndex, optional out UIState StateThatWasRemoved)
	Vector	DeProject (const out Vector PixelPosition ) con)
		DisablePlayerInput (byte PlayerIndex, optional bool bRecurse=true ))
	bool	DisableWidget (int PlayerIndex ))
		EnablePlayerInput (byte PlayerIndex, optional bool bRecurse=true ))
	bool	EnableWidget (int PlayerIndex ))
	UIObject	FindChild (name WidgetName, optional bool bRecurse ) con)
	int	FindChildIndex (name WidgetName ) con)
	UIObject	FindChildUsingID (WIDGET_ID WidgetID, optional bool bRecurse ) con)
		FindEventsOfClass (class<UIEvent> EventClassToFind, out array<UIEvent> out_EventInstances, optional UIState LimitScope, optional bool bExactClass)
	bool	FocusFirstControl (UIScreenObject Sender, optional int PlayerIndex=GetBestPlayerIndex())
	bool	FocusLastControl (UIScreenObject Sender, optional int PlayerIndex=GetBestPlayerIndex())
	int	GetActivePlayerCount ()
	float	GetAspectRatioAutoScaleFactor (optional Font BaseFont ) con)
	int	GetBestControllerId ()))
	int	GetBestPlayerIndex () con)
	float	GetBounds (EUIOrientation Dimension, EPositionEvalType OutputType=EVALPOS_None, optional bool bIgnoreDockPadding) con)
	matrix	GetCanvasToScreen () con)
	array<UIObject>	GetChildren (optional bool bRecurse, optional array ExclusionSet ) con)
	UIState	GetCurrentState (INT PlayerIndex=INDEX_NONE)
		GetDockedWidgets (out array<UIObject> out_DockedWidgets, optional EUIWidgetFace SourceFace=UIFACE_MAX, optional EUIWidgetFace TargetFace=UIFACE_MAX ) con)
	UIObject	GetFocusedControl (optional bool bRecurse, optional int PlayerIndex=GetBestPlayerIndex() ) con)
	Matrix	GetInverseCanvasToScreen () con)
	UIObject	GetLastFocusedControl (optional bool bRecurse, optional int PlayerIndex=GetBestPlayerIndex() ) con)
	ELoginStatus	GetLoginStatus (int ControllerId=INDEX_NONE))
	ENATType	GetNATType ()))
	int	GetObjectCount () con)
	UIScreenObject	GetParent ()
	LocalPlayer	GetPlayerOwner (optional int PlayerIndex=INDEX_NONE)
	float	GetPosition (EUIWidgetFace Face, EPositionEvalType OutputType=EVALPOS_None, optional bool bZeroOrigin, optional bool bIgnoreDockPadding ) con)
	vector	GetPositionVector (optional bool bIncludeParentPosition=true ) con)
	int	GetSupportedPlayerCount ()
		GetSupportedUIActionKeyNames (out array<Name> out_KeyNames)
	float	GetViewportHeight () con)
	bool	GetViewportOffset (out Vector2D out_ViewportOffset ) con)
	bool	GetViewportOrigin (out Vector2D out_ViewportOrigin ) con)
	float	GetViewportScale () con)
	bool	GetViewportSize (out Vector2D out_ViewportSize ) con)
	float	GetViewportWidth () con)
	string	GetWidgetPathName ()
	bool	HasActiveStateOfClass (class<UIState> StateClass, int PlayerIndex, optional out int StateIndex)
	bool	HasLinkConnection ()))
		Initialize (UIScene inOwnerScene, optional UIObject inOwner)
		Initialized ()
		InitializePlayerTracking ()
	int	InsertChild (UIObject NewChild, optional int InsertIndex = INDEX_NONE, optional bool bRenameExisting=true)
	bool	IsActive (optional int PlayerIndex=GetBestPlayerIndex() ) con)
	bool	IsEnabled (optional int PlayerIndex=GetBestPlayerIndex(), optional bool bCheckOwnerChain=true ) con)
	bool	IsFocused (optional int PlayerIndex=GetBestPlayerIndex() ) con)
	bool	IsHidden ()))
	bool	IsHoldingAlt (int ControllerId)
	bool	IsHoldingCtrl (int ControllerId)
	bool	IsHoldingShift (int ControllerId)
	bool	IsInitialized ()
	bool	IsLoggedIn (optional int ControllerId=INDEX_NONE, optional bool bRequireOnlineLogin ))
	bool	IsNeverFocused () con)
	bool	IsPressed (optional int PlayerIndex=GetBestPlayerIndex() ) con)
	bool	IsVisible ()))
	bool	KillFocus (UIScreenObject Sender, optional int PlayerIndex=GetBestPlayerIndex())
		LogCurrentState (int Indent ))
	bool	NavigateFocus (UIScreenObject Sender, EUIWidgetFace Direction, optional int PlayerIndex=GetBestPlayerIndex())
	bool	NextControl (UIScreenObject Sender, optional int PlayerIndex=GetBestPlayerIndex())
		OnChangeVisibility (UIAction_ChangeVisibility Action ))
		OnConsoleCommand (UIAction_ConsoleCommand Action ))
		OnSetControllerId (UIAction_SetControllerId Action ))
		OnShowAchievementsUI (UIAction_ShowAchievementsUI Action))
		OnShowContentMarketplaceUI (UIAction_ShowContentMarketplaceUI Action))
		OnShowFeedbackUI (UIAction_ShowFeedbackUI Action))
		OnShowFriendInviteUI (UIAction_ShowFriendInviteUI Action))
		OnShowFriendsUI (UIAction_ShowFriendsUI Action))
		OnShowGamerCardUI (UIAction_ShowGamerCardUI Action))
		OnShowMembershipMarketplaceUI (UIAction_ShowMembershipMarketplaceUI Action))
		OnShowMessagesUI (UIAction_ShowMessagesUI Action))
		OnShowPlayersUI (UIAction_ShowPlayersUI Action))
		OverrideLastFocusedControl (int PlayerIndex, UIObject ChildToFocus)
	Vector	PixelToCanvas (const out Vector2D PixelPosition ) con)
	Vector4	PixelToScreen (const out Vector2D PixelPosition ) con)
	bool	PlayUISound (name SoundCueName, optional int PlayerIndex=0)
		PostInitialize ()
	bool	PrevControl (UIScreenObject Sender, optional int PlayerIndex=GetBestPlayerIndex())
		PrivateSetVisibility (bool bVisible ))
	Vector	Project (const out Vector CanvasPosition ) con)
		RebuildNavigationLinks ()
	bool	RemoveChild (UIObject ExistingChild, optional array<UIObject> ExclusionSet)
	array<UIObject>	RemoveChildren (array<UIObject> ChildrenToRemove)
		RemovedChild (UIScreenObject WidgetOwner, UIObject OldChild, optional array<UIObject> ExclusionSet)
		RemovedFromParent (UIScreenObject WidgetOwner)
		RemovePlayerData (int PlayerIndex, LocalPlayer RemovedPlayer)
	bool	ReplaceChild (UIObject ExistingChild, UIObject NewChild)
		RequestFormattingUpdate ()
		RequestPrimitiveReview (bool bReinitializePrimitives, bool bReviewPrimitiveUsage)
		RequestSceneUpdate (bool bDockingStackChanged, bool bPositionsChanged, bool bNavLinksOutdated=FALSE, bool bWidgetStylesChanged=FALSE)
	Vector	ScreenToCanvas (const out Vector4 ScreenPosition ) con)
	Vector2D	ScreenToPixel (const out Vector4 ScreenPosition ) con)
	bool	SetEnabled (bool bEnabled, int PlayerIndex=GetBestPlayerIndex())
	bool	SetFocus (UIScreenObject Sender, optional int PlayerIndex=GetBestPlayerIndex())
	bool	SetFocusToChild (optional UIObject ChildToFocus, optional int PlayerIndex=GetBestPlayerIndex())
		SetInputMask (byte NewInputMask, optional bool bRecurse=true ))
		SetPosition (float NewValue, EUIWidgetFace Face, EPositionEvalType InputType=EVALPOS_PixelOwner, optional bool bZeroOrigin)
		SetVisibility (bool bIsVisible ))

bInitialized Source code

Indicates whether this widget has been initialized. Set from UUIScene/UUIObject::Initialize, immediately after the base version of Initialized has been called, but before Initialize() has been called on the children of the widget.

bSupports3DPrimitives Source code

Indicates whether this widget uses 3D primitives.

Children Source code

list of UIObjects which are owned by this UIObject

DefaultStates Source code

The states that should exist in this widget's InactiveStates array by default. When the widget is initialized, the InactiveStates array is iterated through, and if there are no states in the InactiveStates array that have a class matching a DefaultState, a new UIState object of that class is instanced and placed into the InactiveStates array.

EventProvider Source code

FocusControls Source code

The children of this widget that are in special states (i.e. focused control, last focused control, etc.) Each element of this array corresponds to the player at the same array index in the Engine.GamePlayers array.

InitialState Source code

Specifies the UIState that this widget will automatically enter when it is initialized.

StateStack Source code

stack of states this widget is currently using

Focus

bNeverFocus Source code

Indicates that this widget should never become the focused control; does not prevent children of this widget from receiving focus (that must be done by calling SetPrivateBehavior(PRIVATE_NotFocusable,true))

FocusPropagation Source code

Determines which children of this widget should receive focus when this widget receives focus. Each element of this array corresponds to the player at the same array index in the Engine.GamePlayers array.

Presentation

bHidden Source code

Controls whether the screen object is visible

Opacity Source code

the opacity of the object

Position Source code

The location of this screen object

ZDepth Source code

Controls how the widget is sorted by the rendering code; higher values push the widget "away" from the screen, while lower values bring the widget "closer" to the screen

Sound

FocusedCue Source code

this sound is played when this widget becomes the focused control

MouseEnterCue Source code

this sound is played when this widget becomes the active control

NavigateDownCue Source code

this sound is played when this widget has a navigate down event

NavigateLeftCue Source code

this sound is played when this widget has a navigate left event

NavigateRightCue Source code

this sound is played when this widget has a navigate right event

NavigateUpCue Source code

this sound is played when this widget has a navigate up event

Splitscreen

PlayerInputMask Source code

A bitmask representing the player indexes that this control will process input for, where the value is generated by left bitshifting by the index of the player. A value of 255 indicates that this control will process input from all players. A value of 1 << 1 indicate that only input from player at index 1 will be acccepted, etc. So value of 3 means that this control processes input from players at indexes 0 and 1. Input from player indexes that do not match the mask will be ignored.

States

InactiveStates Source code

list of states that this screen object can enter

NotifyActiveSkinChanged Source code

Called when the currently active skin has been changed. Reapplies this widget's style and propagates the notification to all children. @note: this delegate is only called if it is actually assigned to a member function.

NotifyActiveStateChanged Source code

Called when a new UIState becomes the widget's currently active state, after all activation logic has occurred.
@param Sender the widget that changed states.
@param PlayerIndex the index [into the GamePlayers array] for the player that activated this state.
@param NewlyActiveState the state that is now active
@param PreviouslyActiveState the state that used the be the widget's currently active state.

NotifyPositionChanged Source code

Called whenever this object changes its position

NotifyResolutionChanged Source code

Called when the viewport rendering this widget's scene is resized.
@param OldViewportSize the previous size of the viewport
@param NewViewportSize the new size of the viewport

NotifyVisibilityChanged Source code

Allows others to receive a notification when this widget's visibility status changes.
@param SourceWidget the widget that changed visibility status
@param bIsVisible whether this widget is now visible.

OnPreRenderCallBack Source code

If set, this delegate will be called as directly before rendering

OnProcessInputAxis Source code

Provides a hook for unrealscript to respond to input using UI input aliases (i.e. Clicked, NextControl, etc.) Called when an input axis event is received which this widget responds to and is in the correct state to process. The axis and states widgets receive input for is managed through the UI editor's key binding dialog (F8). This delegate is called AFTER kismet is given a chance to process the input, but BEFORE any native code processes the input.
@param EventParms information about the input event, including the name of the input alias associated with the current key name (Tab, Space, etc.), event type (Pressed, Released, etc.) and modifier keys (Ctrl, Alt)
@return TRUE to indicate that this input key was processed; no further processing will occur on this input key event.

OnProcessInputKey Source code

Provides a hook for unrealscript to respond to input using UI input aliases (i.e. Clicked, NextControl, etc.) Called when an input key event is received which this widget responds to and is in the correct state to process. The keys and states widgets receive input for is managed through the UI editor's key binding dialog (F8). This delegate is called AFTER kismet is given a chance to process the input, but BEFORE any native code processes the input.
@param EventParms information about the input event, including the name of the input alias associated with the current key name (Tab, Space, etc.), event type (Pressed, Released, etc.) and modifier keys (Ctrl, Alt)
@return TRUE to indicate that this input key was processed; no further processing will occur on this input key event.

OnRawInputAxis Source code

Provides a hook for unrealscript to respond to input using UI input aliases (i.e. Left, Tab, etc.) Called when an input axis event is received which this widget responds to and is in the correct state to process. The axis and states widgets receive input for is managed through the UI editor's key binding dialog (F8). This delegate is called BEFORE kismet is given a chance to process the input.
@param EventParms information about the input event.
@return TRUE to indicate that this input key was processed; no further processing will occur on this input key event.

OnRawInputKey Source code

Provides a hook for unrealscript to respond to input using actual input key names (i.e. Left, Tab, etc.) Called when an input key event is received which this widget responds to and is in the correct state to process. The keys and states widgets receive input for is managed through the UI editor's key binding dialog (F8). This delegate is called BEFORE kismet is given a chance to process the input.
@param EventParms information about the input event.
@return TRUE to indicate that this input key was processed; no further processing will occur on this input key event.

AcceptsPlayerInput Source code

Determines whether this widget can accept input from the player specified
@param PlayerIndex the index of the player to check
@return TRUE if this widget's PlayerInputMask allows it to process input from the specified player.

ActivateEventByClass Source code

Activate the event of the specified class.
@param PlayerIndex the index of the player that activated this event
@param EventClassToActivate specifies the event class that should be activated. If there is more than one instance of a particular event class in this screen object's list of events, all instances will be activated in the order in which they occur in the event provider's list.
@param InEventActivator an optional object that can be used for various purposes in UIEvents
@param bActivateImmediately TRUE to activate the event immediately, causing its output operations to also be processed immediately.
@param IndicesToActivate Indexes into this UIEvent's Output array to activate. If not specified, all output links will be activated
@param out_ActivatedEvents filled with the event instances that were activated.
@note: noexport because non-const optional arrays aren't exported correctly by the script compiler.

ActivateState Source code

Adds the specified state to the screen object's StateStack.
@param StateToActivate the new state for the widget
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated this call
@return TRUE if the widget's state was successfully changed to the new state. FALSE if the widget couldn't change to the new state or the specified state already exists in the widget's list of active states

ActivateStateByClass Source code

Alternate version of ActivateState that activates the first state in the InactiveStates array with the specified class that isn't already in the StateStack

AddedChild Source code

Called immediately after a child has been added to this screen object.
@param WidgetOwner the screen object that the NewChild was added as a child for
@param NewChild the widget that was added

CanAcceptFocus Source code

Determines whether this widget can become the focused control.
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player to check focus availability
@return TRUE if this widget (or any of its children) is capable of becoming the focused control.

CanPlayOnline Source code

@return Returns whether or not the specified player can play online.

CanPropagateFocusFor Source code

Determines whether this widget is allowed to propagate focus chains to and from the specified widget.
@param TestChild the widget to check
@return TRUE if the this widget is allowed to route the focus chain through TestChild.

CanvasToScreen Source code

Transforms a vector from canvas (widget local) space into screen (D3D device) space
@param CanvasPosition a vector representing a location in widget local space.
@return a vector representing that location in screen space.

ConditionalPropagateEnabledState Source code

Propagates the enabled state of this widget to its child widgets, if the widget has the PRIVATE_PropageteState flag set.
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated this call
@param bForce specify TRUE to propagate the enabled state even if this widget doesn't have the PropagateState flag set.
@return TRUE if child widget states were set successfully.

ContainsChild Source code

Returns whether this screen object contains the specified child in its list of children.
@param Child the child to look for
@param bRecurse whether to search child widgets for the specified child. if this value is FALSE, only the Children array of this screen object will be searched for Child.
@return TRUE if Child is contained by this screen object

ContainsChildOfClass Source code

Returns whether this screen object contains a child of the specified class.
@param SearchClass the class to search for.
@param bRecurse indicates whether to search child widgets. if this value is FALSE, only the Children array of this screen object will be searched for instances of SearchClass.
@return TRUE if Child is contained by this screen object

CreatePlayerData Source code

Called when a new player has been added to the list of active players (i.e. split-screen join) after the scene has been activated.
@param PlayerIndex the index [into the GamePlayers array] where the player was inserted
@param AddedPlayer the player that was added

CreateWidget Source code

Utility function for encapsulating constructing a widget
@param Owner the container for the widget. Cannot be none
@param WidgetClass the class of the widget to create. Cannot be none.
@param WidgetArchetype the template to use for creating the widget
@param WidgetName the name to use for the new widget

DeactivateState Source code

Removes the specified state from the screen object's state stack.
@param StateToRemove the state to be removed
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated this call
@return TRUE if the state was successfully removed, or if the state didn't exist in the widget's list of states; false if the state overrode the request to be removed

DeactivateStateByClass Source code

Alternate version of DeactivateState that deactivates the last state in the StateStack array that has the specified class.

DeProject Source code

Converts an absolute pixel position into 3D screen coordinates.
@param PixelPosition the position of the 2D point, in pixels
@return a position tranformed using this widget's rotation and the scene client's projection matrix.

DisablePlayerInput Source code

Disables input processing in this widget for the player located at the specified index of the Engine.GamePlayers array. If this control is no longer masking any players (i.e. the new PlayerInputMask would be 0), the input mask will be reset to allow input from any player.
@param GamepadIndex the gamepad that this control should no longer respond to input for.
@param bRecurse propagate the new input mask to all children of this control.

DisableWidget Source code

EnablePlayerInput Source code

Enables input processing in this widget for the player located at the specified index of the Engine.GamePlayers array. If this control is not currently masking input (i.e. its PlayerInputMask is 255), the input mask will be set to only allow input from the player index specified.
@param PlayerIndex the index of the player that this control should now respond to input for.
@param bRecurse propagate the new input mask to all children of this control.

EnableWidget Source code

wrapper for enabling/disabling widgets

FindChild Source code

Find a child widget with the specified name
@param WidgetName the name of the child to find
@param bRecurse if TRUE, searches all children of this object recursively
@return a pointer to a widget contained by this object that has the specified name, or NULL if no widgets with that name were found

FindChildIndex Source code

Find the index for the child widget with the specified name
@param WidgetName the name of the child to find
@return the index into the array of children for the widget that has the specified name, or -1 if there aren't any widgets with that name.

FindChildUsingID Source code

Find a child widget with the specified GUID
@param WidgetID the ID(GUID) of the child to find
@param bRecurse if TRUE, searches all children of this object recursively
@return a pointer to a widget contained by this object that has the specified GUID, or NULL if no widgets with that name were found

FindEventsOfClass Source code

Finds UIEvent instances of the specified class.
@param EventClassToFind specifies the event class to search for.
@param out_EventInstances an array that will contain the list of event instances of the specified class.
@param LimitScope if specified, only events contained by the specified state's sequence will be returned.
@param bExactClass if TRUE, only events that have the class specified will be found. Otherwise, events of that class or any of its child classes will be found.

FocusFirstControl Source code

Sets focus to the first focus target within this container.
@param Sender the widget that generated the focus change. if NULL, this widget generated the focus change.
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated the focus change.
@return TRUE if focus was successfully propagated to the first focus target within this container.

FocusLastControl Source code

Sets focus to the last focus target within this container.
@param Sender the widget that generated the focus change. if NULL, this widget generated the focus change.
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated the focus change.
@return TRUE if focus was successfully propagated to the last focus target within this container.

GetActivePlayerCount Source code

Returns the number of active split-screen players.

GetAspectRatioAutoScaleFactor Source code

Calculate the correct scaling factor to use for preserving aspect ratios in e.g. string and image formatting.
@param BaseFont if specified, a font which can provide a "base" resolution for the scale; otherwise, uses the values of the DFEAULT_SIZE_X/Y consts as the base resolution.
@param a float representing the aspect ratio percentage to use for scaling fonts and images.

GetBestControllerId Source code

@return the ControllerId for this widget's owner scene's PlayerOwner, or the player that the owning scene last received input from. If the owning scene is NULL, the PlayerOwner is NULL, and no input has been received, returns INDEX_NONE.

GetBestPlayerIndex Source code

Returns the index [into the Engine.GamePlayers array] for the player that this widget's owner scene last received input from, or INDEX_NONE if the scene is NULL or hasn't received any input from players yet.

GetBounds Source code

Returns the width or height for this widget
@param Dimension UIORIENT_Horizontal to get the width, UIORIENT_Vertical to get the height
@param OutputType indicates the format of the returnedvalue
@param bIgnoreDockPadding used to prevent recursion when evaluting docking links

GetCanvasToScreen Source code

Returns a matrix which includes the scene client's CanvasToScreen matrix and this widget's tranform matrix.

GetChildren Source code

Gets a list of all children contained in this screen object.
@param bRecurse if FALSE, result will only contain widgets from this screen object's Children array if TRUE, result will contain all children of this screen object, including their children.
@param ExclusionSet if specified, any widgets contained in this array will not be added to the output array.
@return an array of widgets contained by this screen object.
@note: noexport because non-const optional arrays aren't exported correctly by the script compiler.

GetCurrentState Source code

Gets the current UIState of this screen object
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated this call

GetDockedWidgets Source code

Generates a list of all widgets which are docked to this one.
@param out_DockedWidgets receives the list of widgets which are docked to this one
@param SourceFace if specified, only widgets which are docked to this one through the specified face will be considered
@param TargetFace if specified, only widgets which are docked to the specified face on this widget will be considered

GetFocusedControl Source code

Retrieves the child of this widget which is current focused.
@param bRecurse if TRUE, returns the inner-most focused widget; i.e. the widget at the end of the focus chain
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated the focus change.
@return a pointer to the child (either direct or indirect) widget which is in the focused state and is the focused control for its parent widget, or NULL if this widget doesn't have a focused control.

GetInverseCanvasToScreen Source code

Returns the inverse of the canvas to screen matrix.

GetLastFocusedControl Source code

Retrieves the child of this widget which last had focus.
@param bRecurse if TRUE, returns the inner-most previously focused widget; i.e. the widget at the end of the focus chain
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated the focus change.
@return a pointer to the child (either direct or indirect) widget which was previously the focused control for its parent, or NULL if this widget doesn't have a LastFocusedControl

GetLoginStatus Source code

@return Returns the current login status for the specified controller id.

GetNATType Source code

Wrapper for getting the NAT type

GetObjectCount Source code

Returns the number of UIObjects owned by this UIScreenObject, recursively
@return the number of widgets (including this one) contained by this widget, including all child widgets

GetParent Source code

Returns the scene or widget that contains this widget in its Children array.

GetPlayerOwner Source code

Retrieves a reference to a LocalPlayer.
@param PlayerIndex if specified, returns the player at this index in the GamePlayers array. Otherwise, returns the player associated with the owner scene.
@return the player that owns this scene or is located in the specified index of the GamePlayers array.

GetPosition Source code

@Returns the Position of a given face for this widget
@param Face indicates which face to change the position for
@param OutputType indicates the format of the returnedvalue EVALPOS_None: NewValue will be considered to be in whichever format is configured as the ScaleType for the specified face EVALPOS_PercentageOwner: EVALPOS_PercentageScene: EVALPOS_PercentageViewport: Indicates that return value is between 0.0 and 1.0, which represents the percentage of the corresponding base's actual size. EVALPOS_PixelOwner EVALPOS_PixelScene EVALPOS_PixelViewport Indicates that return value is an actual pixel value, relative to the corresponding base.
@param bIgnoreDockPadding used to prevent recursion when evaluting docking links

GetPositionVector Source code

Returns this widget's absolute normalized screen position as a vector.
@param bIncludeParentPosition if TRUE, coordinates returned will be absolute (relative to the viewport origin); if FALSE returned coordinates will be relative to the owning widget's upper left corner, if applicable.

GetSupportedPlayerCount Source code

Returns the maximum number of players that could potentially generate input for this scene. If the owning scene's input mode is INPUTMODE_Free, will correspond to the maximum number of simultaneous gamepads supported by this platform; otherwise, the number of active players.

GetSupportedUIActionKeyNames Source code

Allow Script to add UI Actions

GetViewportHeight Source code

Retrieves the height of the viewport this widget uses for rendering.

GetViewportOffset Source code

Retrieves the virtual viewport offset for the viewport which renders this widget's scene. Only relevant in the UI editor; non-zero if the user has panned or zoomed the viewport.
@param out_ViewportOffset [out] will be filled in with the delta between the viewport's actual origin and virtual origin.
@return TRUE if the viewport origin was successfully retrieved

GetViewportOrigin Source code

Retrieves the virtual origin of the viewport that this widget is rendered within. See additional comments in UISceneClient In the game, this will be non-zero if Scene is for split-screen and isn't for the first player. In the editor, this will be equal to the value of the gutter region around the viewport.
@param out_ViewportOrigin [out] will be filled in with the origin point for the viewport that owns this screen object
@return TRUE if the viewport origin was successfully retrieved

GetViewportScale Source code

Retrieves the scale factor for the viewport which renders this widget's scene. Only relevant in the UI editor.

GetViewportSize Source code

Retrieves the viewport size, accounting for split-screen.
@param out_ViewportSize [out] will be filled in with the width & height of the viewport that owns this screen object
@return TRUE if the viewport size was successfully retrieved

GetViewportWidth Source code

Retrieves the width of the viewport this widget uses for rendering.

GetWidgetPathName Source code

Returns a string representation of this widget's hierarchy. i.e. SomeScene.SomeContainer.SomeWidget

HasActiveStateOfClass Source code

Determine whether there are any active states of the specified class
@param StateClass the class to search for
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated this call
@param StateIndex if specified, will be set to the index of the last state in the list of active states that has the class specified
@return TRUE if there is at least one active state of the class specified

HasLinkConnection Source code

@return Returns the current status of the platform's network connection.

Initialize Source code

Perform all initialization for this widget. Called on all widgets when a scene is opened, once the scene has been completely initialized. For widgets added at runtime, called after the widget has been inserted into its parent's list of children.
@param inOwnerScene the scene to add this widget to.
@param inOwner the container widget that will contain this widget. Will be NULL if the widget is being added to the scene's list of children.

Initialized Source code

Called once this screen object has been completely initialized, before it has called Initialize on its children.

InitializePlayerTracking Source code

Sets up the focus, input, and any other arrays which contain data that tracked uniquely for each active player. Ensures that the arrays responsible for managing focus chains are synched up with the Engine.GamePlayers array.

InsertChild Source code

Insert a widget at the specified location
@param NewChild the widget to insert
@param InsertIndex the position to insert the widget. If not specified, the widget is insert at the end of the list
@param bRenameExisting controls what happens if there is another widget in this widget's Children list with the same tag as NewChild. if TRUE, renames the existing widget giving a unique transient name. if FALSE, does not add NewChild to the list and returns FALSE.
@return the position that that the child was inserted in, or INDEX_NONE if the widget was not inserted

IsActive Source code

Returns TRUE if this widget has a UIState_Active object in its StateStack
@param PlayerIndex the index of the player to check

IsEnabled Source code

Returns TRUE if this widget has a UIState_Enabled object in its StateStack
@param PlayerIndex the index of the player to check
@param bCheckOwnerChain by default, the owner chain is checked as well; specify FALSE to override this behavior.

IsFocused Source code

Returns TRUE if this widget has a UIState_Focused object in its StateStack
@param PlayerIndex the index of the player to check

IsHidden Source code

Accessor for private variable
@returns true if this object is hidden

IsHoldingAlt Source code

Returns TRUE if the player associated with the specified ControllerId is holding the Alt key @fixme - doesn't currently respect the value of ControllerId

IsHoldingCtrl Source code

Returns TRUE if the player associated with the specified ControllerId is holding the Ctrl key @fixme - doesn't currently respect the value of ControllerId

IsHoldingShift Source code

Returns TRUE if the player associated with the specified ControllerId is holding the Shift key @fixme - doesn't currently respect the value of ControllerId

IsInitialized Source code

Returns whether this screen object has been initialized.

IsLoggedIn Source code

@return Returns whether or not the player with the specified controller id is logged in

IsNeverFocused Source code

Getter for bNeverFocus

IsPressed Source code

Returns TRUE if this widget has a UIState_Pressed object in its StateStack
@param PlayerIndex the index of the player to check

IsVisible Source code

Accessor for private variable
@returns true if this object is visible

KillFocus Source code

Deactivates the focused state for this widget.
@param Sender the control that called KillFocus.
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated the focus change.

LogCurrentState Source code

NavigateFocus Source code

Sets focus to the widget bound to the navigation link for specified direction of the Sender. This function is used for navigation between controls in scenes that support unbound (i.e. any direction) navigation.
@param Sender Control that called NavigateFocus. Possible values are: - if NULL is specified, it indicates that this is the first step in a focus change. The widget will attempt to set focus to its most eligible child widget. If there are no eligible child widgets, this widget will enter the focused state and start propagating the focus chain back up through the Owner chain by calling SetFocus on its Owner widget. - if Sender is the widget's owner, it indicates that we are in the middle of a focus change. Everything else proceeds the same as if the value for Sender was NULL. - if Sender is a child of this widget, it indicates that focus has been successfully changed, and the focus is now being propagated upwards. This widget will now enter the focused state and continue propagating the focus chain upwards through the owner chain.
@param Direction the direction to navigate focus.
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated the focus change.
@return TRUE if the next child widget in the navigation network for the specified direction successfully received focus.

NextControl Source code

Sets focus to the next control in the tab order (relative to Sender) for widget. If Sender is the last control in the tab order, propagates the call upwards to this widget's parent widget.
@param Sender the widget to use as the base for determining which control to focus next
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated the focus change.
@return TRUE if we successfully set focus to the next control in tab order. FALSE if Sender was the last eligible child of this widget or we couldn't otherwise set focus to another control.

OnChangeVisibility Source code

Kismet Action Handlers

OnConsoleCommand Source code

OnSetControllerId Source code

Handler function for the SetControllerId action.

OnShowAchievementsUI Source code

Displays the achievements UI
@param Action used to determine which player is requesting the action

OnShowContentMarketplaceUI Source code

Displays the marketplace UI
@param Action used to determine which player is requesting the action

OnShowFeedbackUI Source code

Displays the feedback UI
@param Action used to determine which player is requesting the action

OnShowFriendInviteUI Source code

Displays the friends invite UI
@param Action ignored

OnShowFriendsUI Source code

Displays the friends UI
@param Action used to determine which player is requesting the action

OnShowGamerCardUI Source code

Displays the gamercard UI
@param Action used to determine which player is requesting the action

OnShowMembershipMarketplaceUI Source code

Displays the marketplace UI
@param Action used to determine which player is requesting the action

OnShowMessagesUI Source code

Displays the messages UI
@param Action used to determine which player is requesting the action

OnShowPlayersUI Source code

Displays the players UI
@param Action used to determine which player is requesting the action

OverrideLastFocusedControl Source code

Manually sets the last focused control for this widget; only necessary in cases where a particular child should be given focus but this widget (me) doesn't currently have focus. Setting the last focused control to the ChildToFocus will make it so that ChildToFocus is given focus the next time this widget does.

PixelToCanvas Source code

Transforms a 2D screen coordinate into this widget's local space in canvas coordinates. In other words, converts a screen point into what that point would be on this widget if this widget wasn't rotated.
@param PixelPosition the position of the 2D point; a value from 0 - size of the viewport.
@return a 2D screen coordinate corresponding to where PixelPosition would be if this widget was not rotated.

PixelToScreen Source code

Transforms a vector from pixel (viewport pixels) space into screen (D3D device) space
@param PixelPosition a vector representing a location in viewport pixel space
@return a vector representing that location in screen space.

PlayUISound Source code

Plays the sound cue associated with the specified name; simple wrapper for UIInteraction.PlayUISound
@param SoundCueName the name of the UISoundCue to play; should corresond to one of the values of the UISoundCueNames array.
@param PlayerIndex allows the caller to indicate which player controller should be used to play the sound cue. For the most part, all sounds can be played by the first player, regardless of who generated the play sound event.
@return TRUE if the sound cue specified was found in the currently active skin, even if there was no actual USoundCue associated with that UISoundCue.
@note: noexport because the native version is a static method of UUIScreenObject

PostInitialize Source code

Called after this screen object's children have been initialized

PrevControl Source code

Sets focus to the previous control in the tab order (relative to Sender) for widget. If Sender is the first control in the tab order, propagates the call upwards to this widget's parent widget.
@param Sender the widget to use as the base for determining which control to focus next
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated the focus change.
@return TRUE if we successfully set focus to the previous control in tab order. FALSE if Sender was the first eligible child of this widget or we couldn't otherwise set focus to another control.

PrivateSetVisibility Source code

Changes this widget's visibility. Do not change this method to be public - if you need to bypass overrides of SetVisibility, use the Super/Super(UIScreenObject) syntax.
@param bVisible specify FALSE to hide the widget.

Project Source code

Converts a coordinate from this widget's local space (that is, tranformed by the widget's rotation) into a 2D viewport location, in pixels.
@param CanvasPosition a vector representing a location in widget local space.
@return a coordinate representing a point on the screen in pixel space

RebuildNavigationLinks Source code

Immediately rebuilds the navigation links between the children of this screen object and recalculates the child that should be the first & last focused control.

RemoveChild Source code

Remove an existing child widget from this widget's children
@param ExistingChild the widget to remove
@param ExclusionSet used to indicate that multiple widgets are being removed in one batch; useful for preventing references between the widgets being removed from being severed.
@return TRUE if the child was successfully removed from the list, or if the child was not contained by this widget FALSE if the child could not be removed from this widget's child list.
@note: noexport because non-const optional arrays aren't exported correctly by the script compiler.

RemoveChildren Source code

Removes a group of children from this widget's Children array. All removal notifications are delayed until all children have been removed; useful for removing a group of child widgets without destroying the references between them.
@param ChildrenToRemove the list of child widgets to remove
@return a list of children that could not be removed; if the return array is emtpy, all children were successfully removed.

RemovedChild Source code

Called immediately after a child has been removed from this screen object.
@param WidgetOwner the screen object that the widget was removed from.
@param OldChild the widget that was removed
@param ExclusionSet used to indicate that multiple widgets are being removed in one batch; useful for preventing references between the widgets being removed from being severed. NOTE: If a value is specified, OldChild will ALWAYS be part of the ExclusionSet, since it is being removed.

RemovedFromParent Source code

Notification that this widget's parent is about to remove this widget from its children array. Allows the widget to clean up any references to the old parent.
@param WidgetOwner the screen object that this widget was removed from.

RemovePlayerData Source code

Called when a player has been removed from the list of active players (i.e. split-screen players)
@param PlayerIndex the index [into the GamePlayers array] where the player was located
@param RemovedPlayer the player that was removed

ReplaceChild Source code

Replace an existing child widget with the specified widget.
@param ExistingChild the widget to remove
@param NewChild the widget to replace ExistingChild with
@return TRUE if the ExistingChild was successfully replaced with the specified NewChild; FALSE otherwise.

RequestFormattingUpdate Source code

Flag the scene to refresh all string formatting at the beginning of the next tick.

RequestPrimitiveReview Source code

Notifies the owning UIScene that the primitive usage in this scene has changed and sets flags in the scene to indicate that 3D primitives have been added or removed.
@param bReinitializePrimitives specify TRUE to have the scene detach all primitives and reinitialize the primitives for the widgets which have them. Normally TRUE if we have ADDED a new child to the scene which supports primitives.
@param bReviewPrimitiveUsage specify TRUE to have the scene re-evaluate whether its bUsesPrimitives flag should be set. Normally TRUE if a child which supports primitives has been REMOVED.

RequestSceneUpdate Source code

Tell the scene that it needs to be udpated
@param bDockingStackChanged if TRUE, the scene will rebuild its DockingStack at the beginning the next frame
@param bPositionsChanged if TRUE, the scene will update the positions for all its widgets at the beginning of the next frame
@param bNavLinksOutdated if TRUE, the scene will update the navigation links for all widgets at the beginning of the next frame
@param bWidgetStylesChanged if TRUE, the scene will refresh the widgets reapplying their current styles

ScreenToCanvas Source code

Transforms a vector from screen (D3D device space) space into canvas (widget local) space
@param ScreenPosition a vector representing a location in screen space.
@return a vector representing that location in screen space.

ScreenToPixel Source code

Transforms a vector from screen (D3D device space) into pixel (viewport pixels) space.
@param ScreenPosition a vector representing a location in device space
@return a vector representing that location in pixel space.

SetEnabled Source code

Attempts to set the object to the enabled/disabled state specified.
@param bEnabled Whether to enable or disable the widget.
@param PlayerIndex Player index to set the state for.
@return TRUE if the operation was successful, FALSE otherwise.

SetFocus Source code

Activates the focused state for this widget and sets it to be the focused control of its parent (if applicable)
@param Sender Control that called SetFocus. Possible values are: - if NULL is specified, it indicates that this is the first step in a focus change. The widget will attempt to set focus to its most eligible child widget. If there are no eligible child widgets, this widget will enter the focused state and start propagating the focus chain back up through the Owner chain by calling SetFocus on its Owner widget. - if Sender is the widget's owner, it indicates that we are in the middle of a focus change. Everything else proceeds the same as if the value for Sender was NULL. - if Sender is a child of this widget, it indicates that focus has been successfully changed, and the focus is now being propagated upwards. This widget will now enter the focused state and continue propagating the focus chain upwards through the owner chain.
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated the focus change.

SetFocusToChild Source code

Sets focus to the specified child of this widget.
@param ChildToFocus the child to set focus to. If not specified, attempts to set focus to the most elibible child, as determined by navigation links and FocusPropagation values.
@param PlayerIndex the index [into the Engine.GamePlayers array] for the player that generated the focus change.

SetInputMask Source code

Changes the player input mask for this control, which controls which players this control will accept input from.
@param NewInputMask the new mask that should be assigned to this control
@param bRecurse if TRUE, calls SetInputMask on all child controls as well.

SetPosition Source code

Changes this widget's position to the specified value for the specified face.
@param NewValue the new value (in pixels or percentage) to use
@param Face indicates which face to change the position for
@param InputType indicates the format of the input value EVALPOS_None: NewValue will be considered to be in whichever format is configured as the ScaleType for the specified face EVALPOS_PercentageOwner: EVALPOS_PercentageScene: EVALPOS_PercentageViewport: Indicates that NewValue is a value between 0.0 and 1.0, which represents the percentage of the corresponding base's actual size. EVALPOS_PixelOwner EVALPOS_PixelScene EVALPOS_PixelViewport Indicates that NewValue is an actual pixel value, relative to the corresponding base.
@param bZeroOrigin FALSE indicates that the value specified includes the origin offset of the viewport.

SetVisibility Source code

Changes whether this widget is visible or not. Should be overridden in child classes to perform additional logic or abort the visibility change.
@param bIsVisible TRUE if the widget should be visible; false if not.

defaultproperties
{
   Position=(Value[2]=1.000000,Value[3]=1.000000,ScaleType[0]=EVALPOS_PercentageOwner,ScaleType[1]=EVALPOS_PercentageOwner,ScaleType[2]=EVALPOS_PercentageOwner,ScaleType[3]=EVALPOS_PercentageOwner)
   DefaultStates(0)=Class'Engine.UIState_Enabled'
   DefaultStates(1)=Class'Engine.UIState_Disabled'
   InitialState=Class'Engine.UIState_Enabled'
   PlayerInputMask=255
   Opacity=1.000000
   FocusedCue="Focused"
   NavigateUpCue="NavigateUp"
   NavigateDownCue="NavigateDown"
   NavigateLeftCue="NavigateLeft"
   NavigateRightCue="NavigateRight"
   Name="Default__UIScreenObject"
   ObjectArchetype=UIRoot'Engine.Default__UIRoot'
}