`InputActionLabel` is a drag-and-drop `Class.GuiObject` that automatically
shows the appropriate key or icon for an `Class.InputAction` based on the
player's current input device (keyboard/mouse, gamepad, touch, VR). When the
player switches devices or the binding is rebound, the label updates instantly
without scripting.

Rendering of the `InputActionLabel` depends on the `Class.InputAction` (linked
through `Class.InputActionLabel.InputAction`) and that action's child
`Class.InputBinding|InputBindings`. As the label resolves what to show, it
follows this order:

1. **Custom Images** — If child `Class.InputBinding|InputBindings` have their
   `Class.InputBinding.DisplayImage|DisplayImage` property set, the label
   renders those images directly, optionally modified by
   `Class.InputActionLabel.ImageColor3|ImageColor3` and
   `Class.InputActionLabel.ImageTransparency|ImageTransparency`.

2. **Platform Key Images** — Lacking custom images, the label renders
   platform-provided images for child `Class.InputBinding|InputBindings`
   through `Class.UserInputService:GetImageForKeyCode()`, if such images are
   available. Composite bindings with modifiers show multiple icons with `+`
   separators.

3. **Custom Names** — Lacking available images, if child
   `Class.InputBinding|InputBindings` have their
   `Class.InputBinding.DisplayName|DisplayName` property set, the label
   renders that text in a style defined by
   `Class.InputActionLabel.FontFace|FontFace`,
   `Class.InputActionLabel.TextColor3|TextColor3`,
   `Class.InputActionLabel.TextSize|TextSize`,
   `Class.InputActionLabel.TextTransparency|TextTransparency`,
   `Class.InputActionLabel.TextWrapped|TextWrapped`,
   `Class.InputActionLabel.TextXAlignment|TextXAlignment`, and
   `Class.InputActionLabel.TextYAlignment|TextYAlignment`.

4. **Platform Key Strings** — Lacking all of the above, the label renders
   platform-provided strings through
   `Class.UserInputService:GetStringForKeyCode()`.

5. If no `Class.InputAction` is assigned or no child `Class.InputBinding`
   exists, the label renders a placeholder icon.


InputActionLabel

This property is similar to `Class.TextLabel.FontFace` and determines the
font family, weight, and style used when the label renders in a text mode.


InputActionLabel.FontFace

Determines the font used to render text.


This property determines how label images are colorized. When set to
white, no colorization occurs. This property is useful for reusing image
assets; if the source images are completely white with transparency, you
can set the entire label color at once with this property.


InputActionLabel.ImageColor3

Determines how rendered label images will be colorized.


This property determines the alpha of rendered label images. A value of
`0` is completely opaque and a value of `1` is completely transparent
(invisible).


InputActionLabel.ImageTransparency

Determines the transparency of rendered label images.


The `Class.InputAction` instance for which to have the label automatically
resolve and display its preferred binding. When the binding changes (due
to rebinding or input device switching), the label updates automatically.

Setting this to `nil` clears the display and shows the placeholder.


InputActionLabel.InputAction

The `Class.InputAction` whose preferred binding this label displays.


Contains the `Datatype.Content` of the first resolved image when the label
renders in an image mode. Empty when in text or placeholder mode. This is
a read-only property set by the engine when the binding resolves.


InputActionLabel.ResolvedImageContent

Read-only. The resolved image content currently being displayed.


Contains the composed key name string such as `Ctrl + Shift + Space` when
the label renders in text mode. Empty when the label renders in image or
placeholder mode. This is a read-only property set by the engine when the
binding resolves.


InputActionLabel.ResolvedText

The resolved key name string currently being displayed.


This property determines the color of all text rendered by the label.


InputActionLabel.TextColor3

Controls the font size in pixels for text mode rendering. Value is clamped
between `1` and `200`.


InputActionLabel.TextSize

Determines the line height of text in offsets.


This property determines the transparency of all text rendered by the
label.


InputActionLabel.TextTransparency

Determines the transparency of rendered text.


When `true`, text renders on multiple lines within the label's space so
that `Class.InputActionLabel.TextSize|TextSize` lines never exceed the
`Class.GuiBase2d.AbsoluteSize` of the object. This is achieved by breaking
long lines of text into multiple lines.


InputActionLabel.TextWrapped

Determines if text wraps to multiple lines within the label's space.


This property determines the horizontal alignment of text rendered within
the label's space.


InputActionLabel.TextXAlignment

Determines the horizontal alignment of rendered text.


This property determines the vertical alignment of text rendered within
the label's space.


InputActionLabel.TextYAlignment

Determines the vertical alignment of rendered text.


A `Class.GuiObject` that automatically displays the keybinding for an action
as text or an image.


`Class.GuiObject` è una classe astratta (proprio come `Class.BasePart`) per un oggetto dell'interfaccia utente 2D. Definisce tutte le proprietà relative alla visualizzazione di un oggetto dell'interfaccia utente grafica (GUI) come `Class.GuiObject.Size|Size` e `Class.GuiObject.Position|Position`. Ha anche alcune proprietà utili di sola lettura come `Class.GuiObject.AbsolutePosition|AbsolutePosition`, `Class.GuiObject.AbsoluteSize|AbsoluteSize` e `Class.GuiObject.AbsoluteRotation|AbsoluteRotation`.

Per manipolare il layout degli oggetti GUI in modi speciali, puoi usare una struttura di layout come [list/flex](/ui/list-flex-layouts) o [grid](/ui/grid-table-layouts), e puoi stilizzarli oltre alle loro proprietà fondamentali tramite [appearance modifiers](/ui/appearance-modifiers).

Sebbene sia possibile rilevare eventi di pressione dei pulsanti del mouse su qualsiasi oggetto GUI utilizzando `Class.GuiObject.InputBegan|InputBegan` e `Class.GuiObject.InputEnded|InputEnded`, solo `Class.ImageButton` e `Class.TextButton` hanno eventi dedicati convenienti come `Class.TextButton.Activated|Activated` per rilevare clic/prese.

L'esempio seguente presume che sia all'interno di un GuiObject come un `TextButton`, e
che la proprietà `Class.GuiObject.Draggable` sia impostata su true. Stampa
il UDim2 da dove il giocatore ha iniziato a trascinare l'oggetto.

Questo evento si attiva quando un giocatore inizia a trascinare l'oggetto.

Vedi anche `Class.GuiObject.DragStopped`.

GuiObject.DragBegin

initialPosition

Un valore `Datatype.UDim2` della posizione del `Class.GuiObject` prima che inizi qualsiasi operazione di trascinamento.

Attivato quando un giocatore inizia a trascinare l'oggetto.

L'esempio qui sotto presuppone che sia all'interno di un GuiObject come un `TextButton`, e
che la proprietà `Class.GuiObject.Draggable` sia impostata su true. Stampa
e le coordinate X e Y in cui il giocatore ha smesso di trascinare il GUI. Ad esempio, se il
giocatore smettesse di trascinare l'oggetto a 189, 180, il seguente messaggio verrebbe stampato: Il
giocatore ha smesso di trascinare il GuiObject a (189, 180)

Questo evento si attiva quando un giocatore smette di trascinare l'oggetto.

Vedi anche `Class.GuiObject.DragBegin`.

GuiObject.DragStopped

La posizione dello schermo del mouse in **X** in pixel, relativa all'angolo superiore sinistro dello schermo.

La posizione dello schermo del mouse in **Y** in pixel, relativa all'angolo superiore sinistro dello schermo.

Attivato quando un giocatore smette di trascinare l'oggetto.

Il seguente esempio dimostra uno dei molti esempi di utilizzo per gestire l'input dell'utente
dall'evento InputBegan a seconda del suo tipo.

Affinché questo funzioni come previsto, deve essere posizionato in un `LocalScript`
e deve essere un figlio di _gui_.

Questo evento si attiva quando un utente inizia a interagire con il `Class.GuiObject` tramite un dispositivo di interfaccia uomo-computer (pulsante del mouse premuto, inizio tocco, pulsante della tastiera premuto, ecc).

Il `Class.UserInputService` ha un evento dal nome simile che non è limitato a un elemento UI specifico: `Class.UserInputService.InputBegan`.

Questo evento si attiva sempre indipendentemente dallo stato del gioco.

Vedi anche `Class.GuiObject.InputEnded` e `Class.GuiObject.InputChanged`.

GuiObject.InputBegan

input

Un `Class.InputObject`, che contiene dati utili per interrogare l'input dell'utente
come il `Enum.UserInputType|tipo di input`,
`Enum.UserInputState|stato dell'input`, e
`Class.InputObject.Position|coordinate sullo schermo dell'input`.

Attivato quando un utente inizia a interagire attraverso un dispositivo di interfaccia uomo-computer (pulsante del mouse premuto, inizio tocco, pulsante della tastiera premuto, ecc).

Il seguente esempio dimostra uno dei tanti esempi di utilizzo della gestione dell'input dell'utente
tramite InputChanged a seconda del suo tipo.

Affinché questo funzioni come previsto, deve essere inserito in uno `LocalScript`
e un figlio di _gui_.

Questo evento si attiva quando un utente cambia il modo in cui sta interagendo tramite un dispositivo di interfaccia uomo-computer (pulsante del mouse premuto, inizio tocco, pulsante della tastiera premuto, ecc).

Il `Class.UserInputService` ha un evento dal nome simile che non è limitato a un elemento UI specifico: `Class.UserInputService.InputChanged`.

Questo evento si attiva sempre indipendentemente dallo stato del gioco.

Vedi anche `Class.GuiObject.InputBegan` e `Class.GuiObject.InputEnded`.

GuiObject.InputChanged

Attivato quando un utente cambia il modo in cui sta interagendo tramite un dispositivo di interfaccia uomo-computer (pulsante del mouse premuto, inizio tocco, pulsante della tastiera premuto, ecc).

Il seguente esempio dimostra uno dei tanti casi d'uso per gestire l'input dell'utente
tramite InputEnded a seconda del suo tipo.

Affinché questo funzioni come previsto, deve essere collocato in uno `LocalScript`
e un figlio di _gui_.

L'evento InputEnded si attiva quando un utente smette di interagire tramite un dispositivo di interfaccia uomo-computer (pulsante del mouse premuto, inizio tocco, pulsante della tastiera premuto, ecc).

Il `Class.UserInputService` ha un evento dal nome simile che non è limitato a un elemento UI specifico: `Class.UserInputService.InputEnded`.

Questo evento si attiva sempre indipendentemente dallo stato del gioco.

Vedi anche `Class.GuiObject.InputBegan` e `Class.GuiObject.InputChanged`.

GuiObject.InputEnded

Un `Class.InputObject`, che contiene dati utili per interrogare l'input dell'utente
come il `Enum.UserInputType`, `Enum.UserInputState`, e
`Class.InputObject.Position`.

Attivato quando un utente smette di interagire tramite un dispositivo di interfaccia uomo-computer (pulsante del mouse premuto, inizio tocco, pulsante della tastiera premuto, ecc).

Il seguente esempio stampa la posizione del mouse, in pixel, quando entra nell'elemento GUI.

L'evento MouseEnter si attiva quando un utente sposta il proprio mouse in un elemento `Class.GuiObject`.

Si prega di non fare affidamento sugli argomenti `x` e `y` passati da questo evento come modo infallibile per determinare dove si trova il mouse dell'utente quando entra in una GUI. Queste coordinate possono variare anche quando il mouse entra nella GUI dallo stesso bordo - in particolare quando il mouse entra rapidamente nell'elemento. Questo è dovuto al fatto che le coordinate indicano la posizione del mouse quando si attiva l'evento piuttosto che il momento esatto in cui il mouse entra nella GUI.

Questo evento si attiva anche quando l'elemento GUI viene renderizzato sotto un altro elemento.

Se desideri monitorare quando il mouse di un utente lascia un elemento GUI, puoi utilizzare l'evento `Class.GuiObject.MouseLeave`.

##### Vedi anche

- `Class.GuiObject.MouseLeave`
- `Class.GuiObject.MouseMoved`
- `Class.GuiObject.MouseWheelForward`
- `Class.GuiObject.MouseWheelBackward`

GuiObject.MouseEnter

La coordinata dello schermo del mouse in **X** in pixel, relativa all'angolo superiore sinistro dello schermo.

La coordinata dello schermo del mouse in **Y** in pixel, relativa all'angolo superiore sinistro dello schermo.

Si attiva quando un utente sposta il proprio mouse in un elemento GUI.

L'evento MouseLeave si attiva quando un utente sposta il proprio mouse fuori da un elemento `Class.GuiObject`.

Si prega di non fare affidamento sugli argomenti `x` e `y` passati da questo evento come modo infallibile per determinare dove si trova il mouse dell'utente quando lascia una GUI. Queste coordinate possono variare anche quando il mouse lascia la GUI dallo stesso bordo - in particolare quando il mouse lascia rapidamente l'elemento. Questo è dovuto al fatto che le coordinate indicano la posizione del mouse quando si attiva l'evento piuttosto che il momento esatto in cui il mouse lascia la GUI.

Questo evento si attiva anche quando l'elemento GUI viene renderizzato sotto un altro elemento.

##### Vedi anche

- `Class.GuiObject.MouseEnter`
- `Class.GuiObject.MouseMoved`
- `Class.GuiObject.MouseWheelForward`
- `Class.GuiObject.MouseWheelBackward`

GuiObject.MouseLeave

Si attiva quando un utente sposta il proprio mouse fuori da un elemento GUI.

Si attiva ogni volta che un utente muove il proprio mouse mentre si trova in un elemento `Class.GuiObject`. È simile a `Class.Mouse.Move`, che si attiva indipendentemente dal fatto che il mouse dell'utente si trovi su un elemento GUI.

Nota che questo evento si attiva quando la posizione del mouse viene aggiornata, quindi si attiverà ripetutamente mentre viene mosso.

Gli argomenti `x` e `y` indicano le coordinate di schermo aggiornate del mouse dell'utente in pixel. Queste possono essere utili per determinare la posizione del mouse nella GUI, nello schermo e il delta rispetto alla posizione precedente del mouse se viene tracciato in una variabile globale.

Il codice sottostante dimostra come determinare l'offset `Datatype.Vector2` del mouse dell'utente rispetto a un elemento GUI:

```lua
local Players = game:GetService("Players")

local CustomScrollingFrame = script.Parent
local SubFrame = CustomScrollingFrame:FindFirstChild("SubFrame")

local mouse = Players.LocalPlayer:GetMouse()

local function getPosition(X, Y)
	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 - 36))
	print(pos)
end

CustomScrollingFrame.MouseMoved:Connect(getPosition)
```
Nota che questo evento potrebbe non attivarsi esattamente quando il mouse dell'utente entra o esce da un elemento GUI. Pertanto, gli argomenti `x` e `y` potrebbero non corrispondere perfettamente alle coordinate dei bordi della GUI.

##### Vedi anche

- `Class.GuiObject.MouseEnter`
- `Class.GuiObject.MouseLeave`
- `Class.GuiObject.MouseWheelForward`
- `Class.GuiObject.MouseWheelBackward`

GuiObject.MouseMoved

Si attiva ogni volta che un utente muove il proprio mouse mentre si trova all'interno di un elemento GUI.

L'evento WheelBackward si attiva quando un utente scorre la rotella del mouse all'indietro mentre il mouse è sopra un elemento `Class.GuiObject`. È simile a `Class.Mouse.WheelBackward`, che si attiva indipendentemente dal fatto che il mouse dell'utente si trovi su un elemento GUI.

Questo evento si attiva solo come indicatore del movimento all'indietro della rotella. Ciò significa che gli argomenti delle coordinate del mouse `x` e `y` non cambiano a causa di questo evento. Queste coordinate cambiano solo quando il mouse si muove, il che può essere monitorato dall'evento `Class.GuiObject.MouseMoved`.

##### Vedi anche

- `Class.GuiObject.MouseEnter`
- `Class.GuiObject.MouseLeave`
- `Class.GuiObject.MouseMoved`
- `Class.GuiObject.MouseWheelForward`

GuiObject.MouseWheelBackward

Si attiva quando un utente scorre la rotella del mouse all'indietro mentre il mouse è sopra un elemento GUI.

L'evento WheelForward si attiva quando un utente scorre la rotella del mouse in avanti mentre il mouse è sopra un elemento `Class.GuiObject`. È simile a `Class.Mouse.WheelForward`, che si attiva indipendentemente dal fatto che il mouse dell'utente si trovi su un elemento GUI.

Questo evento si attiva solo come indicatore del movimento in avanti della rotella. Ciò significa che le coordinate del mouse **X** e **Y** non cambiano a causa di questo evento. Queste coordinate cambiano solo quando il mouse si muove, il che può essere monitorato dall'evento `Class.GuiObject.MouseMoved`.

##### Vedi anche

- `Class.GuiObject.MouseEnter`
- `Class.GuiObject.MouseLeave`
- `Class.GuiObject.MouseMoved`
- `Class.GuiObject.MouseWheelBackward`

GuiObject.MouseWheelForward

La coordinata **Y** del mouse dell'utente.

Si attiva quando un utente scorre la rotella del mouse in avanti mentre il mouse è sopra un elemento GUI.

Il seguente esempio stampa un messaggio quando l'utente seleziona l'oggetto con un
gamepad.

Affinché questo funzioni come previsto, deve essere inserito in uno `LocalScript`
e un figlio di _gui_.

Questo evento si attiva quando il selettore del gamepad inizia a focalizzarsi sul `Class.GuiObject`.

Se desideri verificare quando il selettore del gamepad smette di focalizzarsi sull'elemento GUI, puoi utilizzare l'evento `Class.GuiObject.SelectionLost`.

Quando una GUI guadagna fuoco di selezione, il valore della proprietà `Class.GuiService.SelectedObject|SelectedObject` cambia anche in quello che guadagna la selezione. Per determinare quale GUI ha guadagnato la selezione, controlla il valore di questa proprietà.

GuiObject.SelectionGained

Attivato quando il GuiObject è focalizzato dal selettore del gamepad.

Il seguente esempio stampa un messaggio quando l'elemento perde il focus su
un gamepad.

Affinché questo funzioni come previsto, deve essere posizionato in un `LocalScript`
e deve essere un figlio di _gui_.

Questo evento si attiva quando il selettore del gamepad smette di focalizzarsi sul `Class.GuiObject`.

Se desideri verificare quando il selettore del gamepad inizia a focalizzarsi sull'elemento GUI, puoi utilizzare l'evento `Class.GuiObject.SelectionGained`.

Quando una GUI perde fuoco di selezione, il valore della proprietà `Class.GuiService.SelectionObject|SelectionObject` cambia in `nil` o nell'elemento GUI che guadagna fuoco di selezione. Per determinare quale GUI ha guadagnato la selezione, o se nessuna GUI è selezionata, controlla il valore di questa proprietà.

GuiObject.SelectionLost

Attivato quando il selettore del gamepad smette di focalizzarsi sul GuiObject.

Questo esempio di codice consente al giocatore di manipolare la posizione sullo schermo di qualche
 elemento UI, come un `Frame`, tenendo premuto sull'elemento UI per un breve
 momento. Quindi, il giocatore muove il dito e rilascio. Durante il gesto,
 il Frame viene colorato di blu con un contorno bianco.

Questo evento si attiva dopo un breve momento in cui il giocatore tiene il dito
sull'elemento dell'interfaccia utente utilizzando un dispositivo abilitato al tocco. Si attiva con una tabella di
`Datatype.Vector2` che descrive le posizioni relative dello schermo delle
dita coinvolte nel gesto. Inoltre, si attiva più volte:
`Enum.UserInputState.Begin` dopo un breve ritardo,
`Enum.UserInputState.Change` se il giocatore muove il dito durante il
gesto, e infine `Enum.UserInputState.End`. Il ritardo dipende dalla piattaforma;
nel Studio è un po' più lungo di un secondo.

GuiObject.TouchLongPress

touchPositions

Un array di `Datatype.Vector2` che descrive le **posizioni** relative delle dita coinvolte nel gesto.

state

Un `Enum.UserInputState` che descrive lo stato del gesto:

- Inizio si attiva una volta all'inizio del gesto (dopo il breve ritardo)
- Cambia si attiva se il giocatore muove il dito mentre preme
- Fine si attiva una volta alla fine del gesto quando rilasciano il dito.

Attivato quando il giocatore inizia, continua e smette di tenere premuto a lungo l'elemento UI.

Questo esempio di codice deve essere inserito in uno `LocalScript` all'interno di un
`Frame` che si trova all'interno di un `Frame` esterno, o di un altro `GuiObject`. Consente al
giocatore di manipolare la posizione del frame interno muovendo il proprio dito sul
frame esterno.

Questo evento si attiva quando il giocatore muove il dito sull'elemento dell'interfaccia utente
utilizzando un dispositivo abilitato al tocco. Si attiva poco prima di
`Class.GuiObject.TouchSwipe` e non si attiva con
`Class.GuiObject.TouchTap`. Questo evento è utile per consentire al giocatore
di manipolare la posizione degli elementi dell'interfaccia utente sullo schermo.

Questo evento si attiva con una tabella di `Datatype.Vector2` che descrive le
posizioni relative dello schermo delle dita coinvolte nel gesto. Inoltre,
si attiva più volte: `Enum.UserInputState.Begin` dopo un
breve ritardo, `Enum.UserInputState.Change` quando il giocatore muove il
dito durante il gesto, e infine con `Enum.UserInputState.End`.

GuiObject.TouchPan

Un array Luau di oggetti `Datatype.Vector2`, ognuno indicante la posizione di tutte le dita coinvolte nel gesto.

totalTranslation

Indica quanto lontano è andato il gesto di panoramica rispetto al suo punto di partenza.

velocity

Indica quanto velocemente viene eseguito il gesto in ogni
dimensione.

Indica lo `Enum.UserInputState` del gesto.

Attivato quando il giocatore muove il proprio dito sull'elemento UI.

Questo esempio di codice è destinato a uno `LocalScript` all'interno di un `Frame` interno che si trova
all'interno di un `Frame` esterno o di un altro `GuiObject`. Consente al giocatore di scalare
il frame interno eseguendo un gesto `Class.GuiObject.TouchPinch` sul
frame esterno.

Questo evento si attiva quando il giocatore utilizza due dita per eseguire un gesto di pizzicamento o di trazione
sull'elemento dell'interfaccia utente utilizzando un dispositivo abilitato al tocco. Un **pizzicamento**
si verifica quando due o più dita si avvicinano, e un **tirare**
si verifica quando si allontanano. Questo evento si attiva in concomitanza con
`Class.GuiObject.TouchPan`. Questo evento è utile per consentire al giocatore
di manipolare la scala (dimensione) degli elementi dell'interfaccia utente sullo schermo, ed è più
spesso utilizzato per funzionalità di zoom.

Questo evento si attiva con una tabella di `Datatype.Vector2` che descrive le
posizioni relative dello schermo delle dita coinvolte nel gesto. Inoltre,
si attiva più volte: `Enum.UserInputState.Begin` dopo un
breve ritardo, `Enum.UserInputState.Change` quando il giocatore muove una dita
durante il gesto, e infine con `Enum.UserInputState.End`. Va notato
che la scala dovrebbe essere utilizzata **moltiplicativamente**.

GuiObject.TouchPinch

Un array Luau di oggetti `Datatype.Vector2`, ciascuno che indica la
posizione di tutte le dita coinvolte nel gesto di pizzicamento.

scale

Un float che indica la differenza dall'inizio del gesto di pizzicamento.

Un float che indica quanto velocemente stia avvenendo il gesto di pizzicamento.

Viene attivato quando il giocatore esegue un gesto di pizzicamento o tiraggio utilizzando due dita
sull'elemento UI.

Questo esempio di codice è destinato a un `LocalScript` all'interno di un `Frame` interno che si trova
all'interno di un `Frame` esterno, o di un altro `GuiObject`. Consente al giocatore di ruotare
il frame interno eseguendo un gesto `Class.GuiObject.TouchRotate` sul
frame esterno.

Questo evento si attiva quando il giocatore utilizza due dita per eseguire un gesto di pizzicamento o di trazione
sull'elemento dell'interfaccia utente utilizzando un dispositivo abilitato al tocco. La rotazione si verifica
quando cambia l'angolo della linea tra due dita. Questo evento si attiva
in concomitanza con `Class.GuiObject.TouchPan`. Questo evento è utile per
consentire al giocatore di manipolare la rotazione degli elementi dell'interfaccia utente sullo
schermo.

Questo evento si attiva con una tabella di `Datatype.Vector2` che descrive le
posizioni relative dello schermo delle dita coinvolte nel gesto. Inoltre,
si attiva più volte: `Enum.UserInputState.Begin` dopo un
breve ritardo, `Enum.UserInputState.Change` quando il giocatore muove una dita
durante il gesto, e infine con `Enum.UserInputState.End`.

GuiObject.TouchRotate

Un array Luau di oggetti `Datatype.Vector2`, ciascuno che indica la
posizione di tutte le dita coinvolte nel gesto.

rotation

Un float che indica quanto la rotazione sia andata dal di</vento.

Un float che indica quanto velocemente viene eseguito il gesto.

Viene attivato quando il giocatore esegue un gesto di rotazione utilizzando due dita sull'
elemento UI.

Questo campione di codice farà rimbalzare un `Frame` (o altro `GuiObject`) quando viene
eseguito un gesto di scorrimento su un dispositivo abilitato al tocco (o sull'emulatore di Studio).
Scorrimenti orizzontali cambieranno la tonalità del
`Class.GuiObject.BackgroundColor3`, mentre scorrimenti verticali cambieranno la
saturazione.

Questo evento si attiva quando il giocatore esegue un gesto di scorrimento sull'elemento dell'interfaccia
utilizzando un dispositivo abilitato al tocco. Si attiva con la direzione del
gesto (Su, Giù, Sinistra o Destra) e il numero di punti di contatto coinvolti
nel gesto. I gesti di scorrimento vengono spesso utilizzati per cambiare schede nelle interfacce mobili.

GuiObject.TouchSwipe

swipeDirection

Un `Enum.SwipeDirection` che indica la direzione del gesto di scorrimento
(Su, Giù, Sinistra o Destra).

numberOfTouches

Il numero di punti di contatto coinvolti nel gesto (di solito 1).

Viene attivato quando il giocatore esegue un gesto di scorrimento sull'elemento UI.

Questo esempio di codice attiverà/disattiverà la `Class.GuiObject.BackgroundTransparency` di un
elemento UI, come un `Frame`, quando viene toccato su un dispositivo abilitato al tocco.

Questo evento si attiva quando il giocatore esegue un gesto di tocco sull'elemento dell'interfaccia
utilizzando un dispositivo abilitato al tocco. Un tocco è un rapido tocco singolo senza alcun
movimento coinvolto (una pressione più lunga attiverebbe
`Class.GuiObject.TouchLongPress`, e muoversi durante il tocco attiverebbe
`Class.GuiObject.TouchPan` e/o `Class.GuiObject.TouchSwipe`). Si attiva
con una tabella di oggetti `Datatype.Vector2` che descrivono le posizioni relative
delle dita coinvolte nel gesto.

GuiObject.TouchTap

Un array di `Datatype.Vector2` che descrivono le **relative**
posizioni delle dita coinvolte nel gesto.

Viene attivato quando il giocatore esegue un gesto di tocco sull'elemento UI.

Questo esempio di codice dimostra un utilizzo più complesso di TweenPosition rilevando quando il tween completa/cancella definendo una funzione di callback. Inoltre, stampa se il tween verrà eseguito.


Sposta dolcemente una GUI a una nuova posizione `Datatype.UDim2` nel tempo specificato utilizzando la `Enum.EasingDirection` e `Enum.EasingStyle` specificate.

Questa funzione restituirà se il tween verrà riprodotto. Non verrà riprodotto se un altro tween sta agendo sul `Class.GuiObject` e il parametro di override è `false`.

Vedi anche `Class.GuiObject:TweenSize()` e `Class.GuiObject:TweenSizeAndPosition()`.

GuiObject:TweenPosition

endPosition

easingDirection

La direzione in cui adattare la GUI alla _endPosition_.

easingStyle

Lo stile in cui adattare la GUI alla _endPosition_.

time

Quanto tempo, in secondi, dovrebbe durare il tween.

override

Se il tween sovrascriverà un tween in corso.

callback

Una funzione di callback da eseguire quando il tween è completato.

Sposta dolcemente una GUI a un nuovo `Datatype.UDim2`.

Questo esempio di codice dimostra l'uso della funzione `Class.GuiObject:TweenSize()`
. Inizia un'animazione sulla proprietà `Class.GuiObject.Size` del genitore
per `UDim2.new(0.5, 0, 0.5, 0)`, che è la metà della dimensione del `GuiObject`
del genitore su entrambi gli assi.

Inoltre, dimostra come il parametro di callback può essere utilizzato per rilevare
quando il tween si ferma (se è stato annullato da un altro tween o completato).


Ridimensiona dolcemente un `Class.GuiObject` a un nuovo `Datatype.UDim2` nel tempo specificato utilizzando la `Enum.EasingDirection` e `Enum.EasingStyle` specificate.

Questa funzione restituirà se il tween verrà riprodotto. Normalmente questo restituirà sempre `true`, ma restituirà `false` se un altro tween è attivo e il parametro di override è impostato su `false`.

Vedi anche `Class.GuiObject:TweenSize()` e `Class.GuiObject:TweenSizeAndPosition()`.

GuiObject:TweenSize

endSize

La dimensione a cui la GUI dovrebbe ridimensionarsi.

La direzione in cui adattare la GUI alla _endSize_.

Lo stile in cui adattare la GUI alla _endSize_.

Ridimensiona dolcemente un `Class.GuiObject` a un nuovo `Datatype.UDim2`.

L'esempio qui sotto transizionerebbe un `Class.Frame` nell'angolo in alto a sinistra della dimensione del genitore
 e ridimensionerebbe a 0.

Ridimensiona e sposta dolcemente una GUI a una nuova dimensione e posizione `Datatype.UDim2` nel tempo specificato utilizzando la `Enum.EasingDirection` e `Enum.EasingStyle` specificate.

Questa funzione restituirà se il tween verrà riprodotto. Normalmente questo restituirà sempre `true`, ma restituirà `false` se un altro tween è attivo e il parametro di override è impostato su `false`.

Vedi anche `Class.GuiObject:TweenSize()` e `Class.GuiObject:TweenSizeAndPosition()`.

GuiObject:TweenSizeAndPosition

La direzione in cui adattare la GUI alla _endSize_ e _endPosition_.

Lo stile in cui adattare la GUI alla _endSize_ e _endPosition_.

Sposta dolcemente una GUI a una nuova dimensione e posizione.

GuiObject

Questo esempio di codice dimostra l'uso della proprietà Active come debounce
per l'evento Activated.

Questa proprietà determina se il `Class.GuiObject` riceverà input nello spazio 3D, come modelli sottostanti con una classe `Class.ClickDetector` come `Class.DragDetector`.

Per gli oggetti `Class.GuiButton` (`Class.ImageButton` e `Class.TextButton`), questa proprietà determina se `Class.GuiButton.Activated|Activated` si attiva (`Class.GuiButton.AutoButtonColor|AutoButtonColor` continuerà a funzionare anche per quelli). Gli eventi `Class.GuiObject.InputBegan|InputBegan`, `Class.GuiObject.InputChanged|InputChanged` e `Class.GuiObject.InputEnded|InputEnded` funzionano normalmente indipendentemente dal valore di questa proprietà.

GuiObject.Active

Determina se questo elemento dell'interfaccia utente riceve input.

Questo esempio di codice sposta un elemento UI ai diversi lati dell'elemento genitore.
Inizia in alto a sinistra e termina in basso a destra. Incolla in un
LocalScript in un Frame, all'interno di un ScreenGui.


Questa proprietà determina il punto di origine di un `Class.GuiObject`, relativo alla sua dimensione assoluta. Il punto di origine determina da dove l'elemento è posizionato (attraverso `Class.GuiObject.Position`) e da cui si espande il `Class.GuiObject.Size` renderizzato.

Vedi [qui](/ui/position-and-size#anchorpoint) per diagrammi illustrati e dettagli.

GuiObject.AnchorPoint

Determina il punto di origine di un `Class.GuiObject`, relativo alla sua dimensione assoluta.

Lo script seguente crea un frame genitore di dimensioni automatiche con
a un `UIListLayout`, poi inserisce diversi oggetti `TextLabel`
onnogenerati di dimensioni automatiche. Nota come il `UIListLayout` genitore si ridimensioni automaticamente per adattarsi al suo
contenuto figlio e le etichette si ridimensionino automaticamente per adattarsi al loro contenuto testuale.
Questo script può essere inserito in un `ScreenGui`.

Questa proprietà viene utilizzata per dimensionare automaticamente gli oggetti UI genitori in base alla dimensione dei loro discendenti. Puoi utilizzare questa proprietà per aggiungere dinamicamente testo e altri contenuti a un oggetto UI durante l'editing o il runtime, e la dimensione si adatterà per adattarsi a quel contenuto.

Quando `Class.GuiObject.AutomaticSize|AutomaticSize` è impostato su un valore `Enum.AutomaticSize` diverso da `Enum.AutomaticSize|None`, questo oggetto UI potrebbe ridimensionarsi in base ai contenuti dei suoi figli.

Per ulteriori informazioni su come utilizzare questa proprietà e come funziona, vedi [qui](/ui/size-modifiers#automatic-sizing).

GuiObject.AutomaticSize

Determina se il ridimensionamento avviene in base ai contenuti dei figli.

Determina il colore dello sfondo del `Class.GuiObject`.

GuiObject.BackgroundColor

Questo esempio di codice fa sì che un Frame genitore scorra attraverso tutti i colori dell'
arcobaleno usando Color3.fromHSV.

Questa proprietà determina il colore di sfondo di un `Class.GuiObject` (il colore di riempimento). Se il tuo elemento contiene testo, come un `Class.TextBox`, `Class.TextButton` o `Class.TextLabel`, assicurati che il colore del tuo sfondo contrasti con il colore del testo.

Un'altra proprietà che determina le proprietà visive dello sfondo è `Class.GuiObject.BackgroundTransparency`; se questa è impostata su `1`, né lo sfondo né il bordo verranno renderizzati.

Vedi anche `Class.GuiObject.BorderColor3|BorderColor3`.

GuiObject.BackgroundColor3

Determina il colore di sfondo del `Class.GuiObject`.

Questa proprietà determina la trasparenza dello sfondo e del bordo del `Class.GuiObject`. Tuttavia, non determina la trasparenza del testo se la GUI è un `Class.TextBox`, `Class.TextButton` o `Class.TextLabel`; la trasparenza del testo è determinata da `Class.TextBox.TextTransparency`, `Class.TextButton.TextTransparency` e `Class.TextLabel.TextTransparency` rispettivamente.

Se questa proprietà è impostata su `1`, né lo sfondo né il bordo verranno renderizzati e lo sfondo della GUI sarà completamente trasparente.

GuiObject.BackgroundTransparency

Determina la trasparenza dello sfondo e del bordo del `Class.GuiObject`.

Determina il colore del bordo del `Class.GuiObject`.

GuiObject.BorderColor

Questo esempio di codice fa sì che il bordo di un GuiObject genitore venga evidenziato quando l'utente passa il mouse sopra l'elemento.

Determina il colore del bordo rettangolare del `Class.GuiObject` (noto anche come colore del contorno). Questo è separato dal `Class.GuiObject.BackgroundColor3` dell'oggetto. Non sarai in grado di vedere il bordo dell'oggetto se la proprietà `Class.GuiObject.BorderSizePixel` è impostata su `0`.

Nota che il componente `Class.UIStroke` consente effetti di bordo più avanzati.

GuiObject.BorderColor3

Questa proprietà determina in che modo il bordo del `Class.GuiObject` è disposto rispetto alle sue dimensioni utilizzando l'enumerazione con lo stesso nome, `Enum.BorderMode`.

Nota che `Class.UIStroke` può sovrascrivere questa proprietà e consentire effetti di bordo più avanzati.

GuiObject.BorderMode

Determina in che modo il bordo del `Class.GuiObject` è disposto rispetto alle sue dimensioni.

Questa proprietà determina quanto è largo il bordo del `Class.GuiObject`, in pixel. Impostando questo valore su 0 si disabilita completamente il bordo.

Nota che `Class.UIStroke` può sovrascrivere questa proprietà e consentire effetti di bordo più avanzati.

GuiObject.BorderSizePixel

Determina la larghezza in pixel del bordo del `Class.GuiObject`.

Una classe astratta per tutti gli oggetti dell'interfaccia utente 2D.

/reference/engine/classes/InputActionLabel.yaml