GuiObject¶
An abstract class for all 2D user interface objects.
Description¶
GuiObject is an abstract class (much like BasePart) for a 2D user interface object. It defines all the properties relating to the display of a graphical user interface (GUI) object such as Size and Position. It also has some useful read‑only properties like AbsolutePosition, AbsoluteSize, and AbsoluteRotation.
To manipulate the layout of GUI objects in special ways, you can use a layout structure such as list/flex or grid, and you can style them beyond their core properties through appearance modifiers.
Although it's possible to detect mouse button events on any GUI object using InputBegan and InputEnded, only ImageButton and TextButton have convenient dedicated events such as Activated to detect click/press.
Inheritance¶
Object → Instance → GuiBase → GuiBase2d → GuiObject
Nova inheritance: Instance → GuiBase → GuiBase2d → GuiObject
Known subclasses: CanvasGroup, Frame, GuiButton, GuiLabel, InputActionLabel, RelativeGui, Scale9Frame, ScrollingFrame, and 5 more
Properties¶
Active Supported Property Determines whether this UI element sinks input.
Determines whether this UI element sinks input.
This property determines whether the GuiObject will sink input to 3D space, such as underlying models with a ClickDetector class like DragDetector.
For GuiButton objects (ImageButton and TextButton), this property determines whether Activated fires (AutoButtonColor will still work for those as well). The events InputBegan, InputChanged, and InputEnded work as normal no matter the value of this property.
AnchorPoint Supported Property Determines the origin point of a GuiObject, relative to its absolute size.
This property determines the origin point of a GuiObject, relative to its absolute size. The origin point determines from where the element is positioned (through GuiObject.Position) and from which the rendered GuiObject.Size expands.
See here for illustrated diagrams and details.
AutomaticSize Supported Property Determines whether resizing occurs based on child content.
Determines whether resizing occurs based on child content.
This property is used to automatically size parent UI objects based on the size of its descendants. You can use this property to dynamically add text and other content to a UI object at edit or run time, and the size will adjust to fit that content.
When AutomaticSize is set to an AutomaticSize value to anything other than None, this UI object may resize depending on its child content.
For more information on how to use this property and how it works, please see here.
BackgroundColor Supported Property Deprecated Determines the color of the GuiObject background.
Determines the color of the GuiObject background.
BackgroundColor3 Supported Property Determines the GuiObject background color.
Determines the GuiObject background color.
This property determines the color of a GuiObject background (the fill color). If your element contains text, such as a TextBox, TextButton, or TextLabel, make sure the color of your background contrasts the text's color.
Another property that determines the visual properties of the background
is GuiObject.BackgroundTransparency; if this is set to 1,
neither the background nor the border will render.
See also BorderColor3.
BackgroundTransparency Supported Property Determines the transparency of the GuiObject background and border.
This property determines the transparency of the GuiObject background and border. It does not, however, determine the transparency of text if the GUI is a TextBox, TextButton, or TextLabel; text transparency is determined TextBox.TextTransparency, TextButton.TextTransparency, and TextLabel.TextTransparency respectively.
If this property is set to 1, neither the background nor the border will
render and the GUI background will be completely transparent.
BorderColor Supported Property Deprecated Determines the color of the GuiObject border.
Determines the color of the GuiObject border.
BorderColor3 Supported Property Determines the color of the GuiObject border.
Determines the color of the GuiObject border.
Determines the color of the GuiObject rectangular border (also
known as the stroke color). This is separate from the object's
GuiObject.BackgroundColor3. You will not be able to see the
object's border if its GuiObject.BorderSizePixel property is set
to 0.
Note that the UIStroke component allows for more advanced border effects.
BorderMode Supported Property Determines in what manner the GuiObject border is laid out relative to its dimensions.
This property determines in what manner the GuiObject border is laid out relative to its dimensions using the enum of the same name, BorderMode.
Note that UIStroke can override this property and allow for more advanced border effects.
BorderSizePixel Supported Property Determines the pixel width of the GuiObject border.
ClipsDescendants Supported Property Determines if descendant GuiObjects outside of the bounds of a parent GUI element should render.
Determines if descendant GuiObjects outside of the bounds of a parent GUI element should render.
This property determines if the GuiObject will clip (make invisible) any portion of descendant GUI elements that would otherwise render outside the bounds of the rectangle.
Rotation Behavior¶
When StarterGui.ClipsDescendantsSupportsRotation is enabled, clipping works correctly for rotated shapes. However, clipping by rotated shapes (when the clipping parent itself is rotated) or by rounded corners (UICorner) is not supported.
When StarterGui.ClipsDescendantsSupportsRotation is not enabled and this GuiObject or any ancestor GuiObject has a non‑zero Rotation, this property is ignored and descendant GUI elements will render regardless of this property's value.
Draggable Supported Property Deprecated Determines whether a GuiObject (and its descendants) can be dragged around the screen.
Interactable Supported Property Determines whether the GuiButton can be interacted with or not, or if the GuiState of the GuiObject is changing or not.
Determines whether the GuiButton can be interacted with or not, or if the GuiState of the GuiObject is changing or not.
On a GuiButton:
- When the Interactable setting on the
GuiButton is set to
false, the GuiButton will no longer be able to be pressed or clicked, and the GuiState will be constantly set to NonInteractable. - When the Interactable setting on the
GuiButton is set to
true, the GuiButton will behave normally again and the GuiState will behave normally.
On a GuiObject:
- When the Interactable setting on the
GuiButton is set to
false, the GuiState will be constantly set to NonInteractable. - When the Interactable setting on the
GuiButton is set to
true, the GuiState will behave normally again.
LayoutOrder Supported Property Controls the sort order of the GuiObject when used with a UIGridStyleLayout.
Controls the sort order of the GuiObject when used with a UIGridStyleLayout.
This property controls the sorting order of the GuiObject when using a UIGridStyleLayout (such as UIListLayout or UIPageLayout) with SortOrder set to SortOrder.LayoutOrder. It has no functionality if the object does not have a sibling UI layout structure.
GuiObjects are sorted in ascending order where lower values take priority over higher values. Objects with equal values fall back to the order they were added in.
If you are unsure if you'll need to add an element between two existing
elements in the future, it's a good practice to use multiples of 100
(0, 100, 200, etc.). This ensures a large gap of layout order values
which you can use for elements ordered in-between other elements.
See also ZIndex which determines the object's rendering order instead of sorting order.
NextSelectionDown Supported Property Sets the GuiObject which will be selected when the gamepad selector is moved downward.
Sets the GuiObject which will be selected when the gamepad selector is moved downward.
This property sets the GuiObject selected when the user moves the gamepad selector downward. If this property is empty, moving the gamepad downward will not change the selected GUI.
Moving the gamepad selector downward sets the GuiService.SelectedObject to this object unless the GUI is not Selectable. Note that this property can be set to a GUI element even if it is not Selectable, so you should ensure that the value of a GUI's selectable property matches your expected behavior.
See also NextSelectionUp, NextSelectionLeft, and NextSelectionRight.
NextSelectionLeft Supported Property Sets the GuiObject which will be selected when the gamepad selector is moved to the left.
Sets the GuiObject which will be selected when the gamepad selector is moved to the left.
This property sets the GuiObject selected when the user moves the gamepad selector to the left. If this property is empty, moving the gamepad to the left will not change the selected GUI.
Moving the gamepad selector to the left sets the GuiService.SelectedObject to this object unless the GUI is not Selectable. Note that this property can be set to a GUI element even if it is not Selectable, so you should ensure that the value of a GUI's selectable property matches your expected behavior.
See also NextSelectionUp, NextSelectionDown, and NextSelectionRight.
NextSelectionRight Supported Property Sets the GuiObject which will be selected when the gamepad selector is moved to the right.
Sets the GuiObject which will be selected when the gamepad selector is moved to the right.
This property sets the GuiObject selected when the user moves the gamepad selector to the right. If this property is empty, moving the gamepad to the right will not change the selected GUI.
Moving the gamepad selector to the right sets the GuiService.SelectedObject to this object unless the GUI is not Selectable. Note that this property can be set to a GUI element even if it is not Selectable, so you should ensure that the value of a GUI's selectable property matches your expected behavior.
See also NextSelectionUp, NextSelectionDown, and NextSelectionLeft.
NextSelectionUp Supported Property Sets the GuiObject which will be selected when the gamepad selector is moved upward.
Sets the GuiObject which will be selected when the gamepad selector is moved upward.
This property sets the GuiObject selected when the user moves the gamepad selector upward. If this property is empty, moving the gamepad upward will not change the selected GUI.
Moving the gamepad selector upward sets the GuiService.SelectedObject to this object unless the GUI is not Selectable. Note that this property can be set to a GUI element even if it is not Selectable, so you should ensure that the value of a GUI's selectable property matches your expected behavior.
See also NextSelectionDown, NextSelectionLeft, NextSelectionRight.
Position Supported Property Determines the pixel and scalar position of the GuiObject.
Determines the pixel and scalar position of the GuiObject.
This property determines the GuiObject pixel and scalar position using a UDim2. Position is centered around the object's GuiObject.AnchorPoint.
The scalar position is relative to the size of the parent GUI element, if any.
The pixel portions of the UDim2 value are the same regardless of the parent GUI's size. The values represent the position of the object in pixels. An object's actual pixel position can be read from the GuiBase2d.AbsolutePosition property.
Rotation Supported Property Determines the number of degrees by which the GuiObject is rotated.
This property determines the number of degrees by which the GuiObject is rotated. Rotation is relative to the center of the object, not the AnchorPoint, meaning you cannot change the point of rotation. Additionally, this property is not compatible with ClipsDescendants.
Selectable Supported Property Determine whether the GuiObject can be selected by a gamepad.
Determine whether the GuiObject can be selected by a gamepad.
This property determines whether the GuiObject can be selected when navigating GUIs using a gamepad.
If this property is true, a GUI can be selected. Selecting a GUI also
sets the GuiService.SelectedObject property to that object.
When this is false, the GUI cannot be selected. However, setting this to
false when a GUI is selected will not deselect it nor change the value
of the GuiService.SelectedObject property.
Add GuiObject.SelectionGained and GuiObject.SelectionLost will not fire for the element. To deselect a GuiObject, you must change the GuiService.SelectedObject property.
This property is useful if a GUI is connected to several GUIs via properties such as this GuiObject.NextSelectionUp, GuiObject.NextSelectionDown, NextSelectionRight, or NextSelectionLeft. Rather than change all of the properties so that the Gamepad cannot select the GUI, you can disable its Selectable property to temporarily prevent it from being selected. Then, when you want the gamepad selector to be able to select the GUI, simply re-enable its selectable property.
SelectionImageObject Supported Property Overrides the default selection adornment used for gamepads.
This property overrides the default selection adornment used for gamepads.
Note that the chosen
SelectionImageObject overlays the
selected GuiObject with the Size of the
image. For best results, you should size the custom SelectionImageObject
via the scale UDim2 values to help ensure that the object
scales properly over the selected element.
Changing the SelectionImageObject for a GuiObject element only affects that element. To affect all of a user's GUI elements, set the PlayerGui.SelectionImageObject property.
To determine or set which GUI element is selected by the user, you can use the GuiService.SelectedObject property. The player uses the gamepad to select different GUI elements, invoking the NextSelectionUp, NextSelectionDown, NextSelectionLeft, and NextSelectionRight events.
SelectionOrder Supported Property The order of GuiObjects selected by the gamepad UI selection.
The order of GuiObjects selected by the gamepad UI selection.
GuiObjects with a lower SelectionOrder are selected earlier than GuiObjects with a higher SelectionOrder when starting the gamepad selection or calling GuiService.Select() on an ancestor. This property does not affect directional navigation. Default value is 0.
Size Supported Property Determines the pixel and scalar size of the GuiObject.
Determines the pixel and scalar size of the GuiObject.
This property determines the GuiObject scalar and pixel size using a UDim2.
The scalar size is relative to the size of the parent GUI element, if any.
The pixel portions of the UDim2 value are the same regardless of the parent GUI's size. The values represent the size of the object in pixels. An object's actual pixel size can be read from the GuiBase2d.AbsoluteSize property.
If the GuiObject has a parent, its size along each axis is also influenced by the parent's SizeConstraint.
SizeConstraint Supported Property Sets the Size axes that the GuiObject will be based on, relative to the size of its parent.
Transparency Supported Property Deprecated A mixed property of BackgroundTransparency and TextTransparency.
A mixed property of BackgroundTransparency and TextTransparency.
Visible Supported Property Determines whether the GuiObject and its descendants will be rendered.
Determines whether the GuiObject and its descendants will be rendered.
This property whether the GuiObject and its descendants will be rendered.
The rendering of individual components of a GuiObject can be controlled individually through transparency properties such as GuiObject.BackgroundTransparency, TextLabel.TextTransparency and ImageLabel.ImageTransparency.
When this property is false, the GuiObject will be ignored by
layout structures such as UIListLayout, UIGridLayout, and
UITableLayout. In other words, the space that the element would
otherwise occupy in the layout is used by other elements instead.
ZIndex Supported Property Determines the order in which a GuiObject renders relative to others.
This property determines the order in which a GuiObject renders relative to others.
By default, GuiObjects render in ascending priority order where those with lower ZIndex values are rendered under those with higher values. You can change the render order within a ScreenGui, SurfaceGui, or BillboardGui by changing the value of its ZIndexBehavior.
If you are unsure if you'll need to add an element between two existing
elements in the future, it's a good practice to use multiples of 100
(0, 100, 200, etc.). This ensures a large gap of render order values
which you can use for elements layered in-between other elements.
See also LayoutOrder which controls the sorting order of a GuiObject when used with a layout structure such as UIListLayout or UIGridLayout.
Methods¶
TweenPosition Supported Function Deprecated Smoothly moves a GUI to a new UDim2.
GuiObject:TweenPosition(UDim2 endPosition, EasingDirection easingDirection = Out, EasingStyle easingStyle = Quad, float time = 1, bool override = false, Function callback = nil): bool
Smoothly moves a GUI to a new UDim2.
Smoothly moves a GUI to a new UDim2 position in the specified
time using the specified EasingDirection and EasingStyle.
This method raises an error if easingStyle is EasingStyle.Bezier
or EasingStyle.Spring.
This function will return whether the tween will play. It will not play if
another tween is acting on the GuiObject and the override
parameter is false.
See also GuiObject.TweenSize() and GuiObject.TweenSizeAndPosition().
Roblox reference signature
TweenSize Supported Function Deprecated Smoothly resizes a GuiObject to a new UDim2.
GuiObject:TweenSize(UDim2 endSize, EasingDirection easingDirection = Out, EasingStyle easingStyle = Quad, float time = 1, bool override = false, Function callback = nil): bool
Smoothly resizes a GuiObject to a new UDim2 in the
specified time using the specified EasingDirection and
EasingStyle. This method raises an error if easingStyle is
EasingStyle.Bezier or EasingStyle.Spring.
This function will return whether the tween will play. Normally this will
always return true, but it will return false if another tween is
active and override is set to false.
See also GuiObject.TweenSize() and GuiObject.TweenSizeAndPosition().
Roblox reference signature
TweenSizeAndPosition Supported Function Deprecated Smoothly moves a GUI to a new size and position.
GuiObject:TweenSizeAndPosition(UDim2 endSize, UDim2 endPosition, EasingDirection easingDirection = Out, EasingStyle easingStyle = Quad, float time = 1, bool override = false, Function callback = nil): bool
Smoothly moves a GUI to a new size and position.
Smoothly resizes and moves a GUI to a new UDim2 size and
position in the specified time using the specified EasingDirection
and EasingStyle. This method raises an error if easingStyle is
EasingStyle.Bezier or EasingStyle.Spring.
This function will return whether the tween will play. Normally this will
always return true, but it will return false if another tween is
active and override is set to false.
See also GuiObject.TweenSize() and GuiObject.TweenSizeAndPosition().
Roblox reference signature
Events¶
DragBegin Supported Event Deprecated Fired when a player begins dragging the object.
Fired when a player begins dragging the object.
This event fires when a player begins dragging the object.
See also GuiObject.DragStopped.
DragStopped Supported Event Deprecated Fired when a player stops dragging the object.
Fired when a player stops dragging the object.
This event fires when a player stops dragging the object.
See also GuiObject.DragBegin.
InputBegan Supported Event Fired when a user begins interacting via a Human-Computer Interface device (Mouse button down, touch begin, keyboard button down, etc).
Fired when a user begins interacting via a Human-Computer Interface device (Mouse button down, touch begin, keyboard button down, etc).
This event fires when a user begins interacting with the GuiObject via a Human-Computer Interface device (Mouse button down, touch begin, keyboard button down, etc).
The UserInputService has a similarly named event that is not restricted to a specific UI element: UserInputService.InputBegan.
This event will always fire regardless of game state.
See also GuiObject.InputEnded and GuiObject.InputChanged.
InputChanged Supported Event Fired when a user changes how they're interacting via a Human-Computer Interface device (Mouse button down, touch begin, keyboard button down, etc).
Fired when a user changes how they're interacting via a Human-Computer Interface device (Mouse button down, touch begin, keyboard button down, etc).
This event fires when a user changes how they're interacting via a Human-Computer Interface device (Mouse button down, touch begin, keyboard button down, etc).
The UserInputService has a similarly named event that is not restricted to a specific UI element: UserInputService.InputChanged.
This event will always fire regardless of game state.
See also GuiObject.InputBegan and GuiObject.InputEnded.
InputEnded Supported Event Fired when a user stops interacting via a Human-Computer Interface device (Mouse button down, touch begin, keyboard button down, etc).
Fired when a user stops interacting via a Human-Computer Interface device (Mouse button down, touch begin, keyboard button down, etc).
The InputEnded event fires when a user stops interacting via a Human-Computer Interface device (Mouse button down, touch begin, keyboard button down, etc).
The UserInputService has a similarly named event that is not restricted to a specific UI element: UserInputService.InputEnded.
This event will always fire regardless of game state.
See also GuiObject.InputBegan and GuiObject.InputChanged.
MouseEnter Supported Event Fires when a user moves their mouse into a GUI element.
Fires when a user moves their mouse into a GUI element.
The MouseEnter event fires when a user moves their mouse into a GuiObject element.
Please do not rely on the x and y arguments passed by this event as a
fool-proof way to determine where the user's mouse is when it enters a
GUI. These coordinates may vary even when the mouse enters the GUI via the
same edge - particularly when the mouse enters the element quickly. This
is due to the fact the coordinates indicate the position of the mouse when
the event fires rather than the exact moment the mouse enters the GUI.
This event fires even when the GUI element renders beneath another element.
If you would like to track when a user's mouse leaves a GUI element, you can use the GuiObject.MouseLeave event.
See Also¶
MouseLeave Supported Event Fires when a user moves their mouse out of a GUI element.
Fires when a user moves their mouse out of a GUI element.
The MouseLeave event fires when a user moves their mouse out of a GuiObject element.
Please do not rely on the x and y arguments passed by this event as a
fool-proof way to determine where the user's mouse is when it leaves a
GUI. These coordinates may vary even when the mouse leaves the GUI via the
same edge - particularly when the mouse leaves the element quickly. This
is due to the fact the coordinates indicate the position of the mouse when
the event fires rather than the exact moment the mouse leaves the GUI.
This event fires even when the GUI element renders beneath another element.
See Also¶
MouseMoved Supported Event Fires whenever a user moves their mouse while it is inside a GUI element.
Fires whenever a user moves their mouse while it is inside a GUI element.
Fires whenever a user moves their mouse while it is inside a GuiObject element. It is similar to Mouse.Move, which fires regardless whether the user's mouse is over a GUI element.
Note, this event fires when the mouse's position is updated, therefore it will fire repeatedly while being moved.
The x and y arguments indicate the updated screen coordinates of the
user's mouse in pixels. These can be useful to determine the mouse's
location on the GUI, screen, and delta since the mouse's previous position
if it is being tracked in a global variable.
The code below demonstrates how to determine the Vector2 offset
of the user's mouse relative to a GUI element.
AbsolutePosition is measured inside the
screen's GUI inset, while the x and y arguments of this event are
screen coordinates that include it, so the sample calls
GetGuiInset() to reconcile the two spaces
instead of assuming a fixed inset size.
local Players = game:GetService("Players")
local GuiService = game:GetService("GuiService")
local CustomScrollingFrame = script.Parent
local SubFrame = CustomScrollingFrame:FindFirstChild("SubFrame")
local mouse = Players.LocalPlayer:GetMouse()
local function getPosition(X, Y)
local topLeftInset = GuiService:GetGuiInset()
local gui_X = CustomScrollingFrame.AbsolutePosition.X
local gui_Y = CustomScrollingFrame.AbsolutePosition.Y
local pos = Vector2.new(math.abs(X - gui_X), math.abs(Y - gui_Y - topLeftInset.Y))
print(pos)
end
CustomScrollingFrame.MouseMoved:Connect(getPosition)
Note that this event may not fire exactly when the user's mouse enters or
exits a GUI element. Therefore, the x and y arguments may not match up
perfectly to the coordinates of the GUI's edges.
See Also¶
MouseWheelBackward Supported Event Fires when a user scrolls their mouse wheel back when the mouse is over a GUI element.
Fires when a user scrolls their mouse wheel back when the mouse is over a GUI element.
The WheelBackward event fires when a user scrolls their mouse wheel back when the mouse is over a GuiObject element. It is similar to Mouse.WheelBackward, which fires regardless whether the user's mouse is over a GUI element.
This event fires merely as an indicator of the wheel's backward movement.
This means that the x and y mouse coordinate arguments don't change as
a result of this event. These coordinates only change when the mouse
moves, which can be tracked by the GuiObject.MouseMoved event.
See Also¶
MouseWheelForward Supported Event Fires when a user scrolls their mouse wheel forward when the mouse is over a GUI element.
Fires when a user scrolls their mouse wheel forward when the mouse is over a GUI element.
The WheelForward event fires when a user scrolls their mouse wheel forward when the mouse is over a GuiObject element. It is similar to Mouse.WheelForward, which fires regardless whether the user's mouse is over a GUI element.
This event fires merely as an indicator of the wheel's forward movement. This means that the X and Y mouse coordinate arguments do not change as a result of this event. These coordinates only change when the mouse moves, which can be tracked by the GuiObject.MouseMoved event.
See Also¶
SelectionGained Supported Event Fired when the GuiObject is being focused on with the Gamepad selector.
Fired when the GuiObject is being focused on with the Gamepad selector.
This event fires when the Gamepad selector starts focusing on the GuiObject.
If you want to check from the Gamepad select stops focusing on the GUI element, you can use the GuiObject.SelectionLost event.
When a GUI gains selection focus, the value of the SelectedObject property also changes to the that gains selection. To determine which GUI gained selection, check the value of this property.
SelectionLost Supported Event Fired when the Gamepad selector stops focusing on the GuiObject.
Fired when the Gamepad selector stops focusing on the GuiObject.
This event fires when the Gamepad selector stops focusing on the GuiObject.
If you want to check from the Gamepad select starts focusing on the GUI element, you can use the GuiObject.SelectionGained event.
When a GUI loses selection focus, the value of the
SelectionObject property changes either
to nil or to the GUI element that gains selection focus. To determine
which GUI gained selection, or if no GUI is selected, check the value of
this property.
TouchLongPress Supported Event Fires when the player starts, continues and stops long-pressing the UI element.
Fires when the player starts, continues and stops long-pressing the UI element.
This event fires after a brief moment when the player holds their finger on the UI element using a touch-enabled device. It fires with a table of Vector2 that describe the relative screen positions of the fingers involved in the gesture. In addition, it fires multiple times: UserInputState.Begin after a brief delay, UserInputState.Change if the player moves their finger during the gesture, and finally UserInputState.End. The delay is platform dependent; in Studio it is a little longer than one second.
TouchPan Supported Event Fires when the player moves their finger on the UI element.
Fires when the player moves their finger on the UI element.
This event fires when the player moves their finger on the UI element using a touch-enabled device. It fires shortly before GuiObject.TouchSwipe would, and does not fire with GuiObject.TouchTap. This event is useful for allowing the player to manipulate the position of UI elements on the screen.
This event fires with a table of Vector2 that describe the relative screen positions of the fingers involved in the gesture. In addition, it fires multiple times: UserInputState.Begin after a brief delay, UserInputState.Change when the player moves their finger during the gesture, and finally with UserInputState.End.
Roblox reference signature
TouchPinch Supported Event Fires when the player performs a pinch or pull gesture using two fingers on the UI element.
Fires when the player performs a pinch or pull gesture using two fingers on the UI element.
This event fires when the player uses two fingers to make a pinch or pull gesture on the UI element using a touch-enabled device. A pinch happens when two or more fingers move closer together, and a pull happens when they move apart. This event fires in conjunction with GuiObject.TouchPan. This event is useful for allowing the player to manipulate the scale (size) of UI elements on the screen, and is most often used for zooming features.
This event fires with a table of Vector2 that describe the relative screen positions of the fingers involved in the gesture. In addition, it fires multiple times: UserInputState.Begin after a brief delay, UserInputState.Change when the player moves a finger during the gesture, and finally with UserInputState.End. It should be noted that the scale should be used multiplicatively.
Roblox reference signature
TouchRotate Supported Event Fires when the player performs a rotation gesture using two fingers on the UI element.
Fires when the player performs a rotation gesture using two fingers on the UI element.
This event fires when the player uses two fingers to make a pinch or pull gesture on the UI element using a touch-enabled device. Rotation occurs when the angle of the line between two fingers changes. This event fires in conjunction with GuiObject.TouchPan. This event is useful for allowing the player to manipulate the rotation of UI elements on the screen.
This event fires with a table of Vector2 that describe the relative screen positions of the fingers involved in the gesture. In addition, it fires multiple times: UserInputState.Begin after a brief delay, UserInputState.Change when the player moves a finger during the gesture, and finally with UserInputState.End.
Roblox reference signature
TouchSwipe Supported Event Fires when the player performs a swipe gesture on the UI element.
Fires when the player performs a swipe gesture on the UI element.
This event fires when the player performs a swipe gesture on the UI element using a touch-enabled device. It fires with the direction of the gesture (Up, Down, Left or Right) and the number of touch points involved in the gesture. Swipe gestures are often used to change tabs in mobile UIs.
TouchTap Supported Event Fires when the player performs a tap gesture on the UI element.
Fires when the player performs a tap gesture on the UI element.
This event fires when the player performs a tap gesture on the UI element using a touch-enabled device. A tap is a quick single touch without any movement involved (a longer press would fire GuiObject.TouchLongPress, and moving during the touch would fire GuiObject.TouchPan and/or GuiObject.TouchSwipe). It fires with a table of Vector2 objects that describe the relative positions of the fingers involved in the gesture.
Inherited members¶
Inherited from GuiBase2d: 17 properties, 36 methods, 7 events. They are documented on the base class page.
5 modern Roblox member(s) are not implemented yet — expand to inspect
Members declared by Roblox's GuiObject class (or by a missing base class) that Nova does not expose. Use this list to scope a migration; the compatibility guide has the recommended workaround.
Properties¶
| Member | Signature | Status | Notes | Flags |
|---|---|---|---|---|
GuiState |
GuiState: GuiState |
Not yet | Determines whether the player's mouse is being actively pressed on the GuiObject or not. | ReadOnly, NotReplicated |
InputSink |
InputSink: InputSink |
Not yet | Controls whether, and how, the GuiObject sinks input that occurs over it. | NotReplicated |
Methods¶
| Member | Signature | Status | Notes | Flags |
|---|---|---|---|---|
TweenPositionInternal |
GuiObject:TweenPositionInternal(endPosition: UDim2, easingDirection: EasingDirection = Out, easingStyle: EasingStyle = Quad, time: float = 1, override: bool = false, callback: Function = nil): bool |
Not yet | — | RobloxScriptSecurity |
TweenSizeAndPositionInternal |
GuiObject:TweenSizeAndPositionInternal(endSize: UDim2, endPosition: UDim2, easingDirection: EasingDirection = Out, easingStyle: EasingStyle = Quad, time: float = 1, override: bool = false, callback: Function = nil): bool |
Not yet | — | RobloxScriptSecurity |
TweenSizeInternal |
GuiObject:TweenSizeInternal(endSize: UDim2, easingDirection: EasingDirection = Out, easingStyle: EasingStyle = Quad, time: float = 1, override: bool = false, callback: Function = nil): bool |
Not yet | — | RobloxScriptSecurity |
Roblox reference: GuiObject
Generated from Nova's API dump and Roblox creator-docs. Nova-only members come from the engine's reflection metadata.