`CanvasGroup` rende i discendenti come un gruppo con colore e trasparenza
applicati al risultato di rendering. I modificatori visivi di `Class.UIComponent` come
`Class.UICorner` e `Class.UIGradient` sotto un `CanvasGroup` si applicheranno
a tutto il gruppo. Si noti che `CanvasGroup` ha sempre
`Class.GuiObject.ClipsDescendants|ClipsDescendants` impostato su `true` e tutti
gi discendenti verranno renderizzati all'interno del viewport del gruppo.

#### Note Importanti

- I discendenti di `CanvasGroup` verranno renderizzati come una texture appiattita solo
  quando l'antenato `Class.LayerCollector` ha il suo
  `Class.LayerCollector.ZIndexBehavior|ZIndexBehavior` impostato su
  `Enum.ZIndexBehavior.Sibling`.
- `CanvasGroup` consuma memoria texture aggiuntiva. La qualità della texture e
  l'uso totale di memoria sono limitati dal `Enum.QualityLevel` del client. Quando
  si supera il limite di memoria, `CanvasGroup` verrà renderizzato come una texture vuota.
- Si raccomanda di utilizzare `CanvasGroup` con dimensioni statiche, altrimenti
  sarebbe necessario creare una nuova texture per adattarsi a nuove dimensioni.


CanvasGroup

Tinta di colore che si applica a tutti i discendenti.

CanvasGroup.GroupColor3

Trasparenza che si applica a tutti i discendenti.

CanvasGroup.GroupTransparency

Mescola i discendenti come un gruppo con colore/trasparenza.

`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`.

Questa proprietà determina se il `Class.GuiObject` ritaglierà (rende invisibile) qualsiasi parte degli elementi GUI discendenti che altrimenti verrebbero renderizzati al di fuori dei limiti del rettangolo.

Nota che `Class.GuiObject.Rotation|Rotation` non è supportato da questa proprietà. Se questo o qualsiasi oggetto GUI antenato ha una `Class.GuiObject.Rotation|Rotation` **non zero**, questa proprietà è **ignorata** e gli elementi GUI discendenti verranno renderizzati indipendentemente dal valore di questa proprietà.

GuiObject.ClipsDescendants

Determina se gli oggetti discendenti `Class.GuiObject|GuiObjects` al di fuori dei limiti di un elemento GUI genitore dovrebbero essere renderizzati.

Questa proprietà indica se un `Class.GuiObject` (e i suoi discendenti) può essere trascinato attorno allo schermo.

GuiObject.Draggable

Determina se un `Class.GuiObject` (e i suoi discendenti) può essere trascinato attorno allo schermo.

Quando il dito del giocatore è premuto e tenuto sul `Class.GuiObject`, lo stato `Class.GuiObject.GuiState|GuiState` del `Class.GuiObject` verrà impostato su `Enum.GuiState.Press|Press`. Allo stesso modo, quando il dito del giocatore viene rilasciato dal `Class.GuiObject`, lo stato `Class.GuiObject.GuiState|GuiState` del `Class.GuiObject` verrà impostato su `Enum.GuiState.Idle|Idle`, e quando `Class.GuiObject.Interactable|Interactable` è disabilitato sul `Class.GuiObject`, lo stato `Class.GuiState` del `Class.GuiObject` verrà impostato su `Enum.GuiState.NonInteractable|NonInteractable`.

GuiObject.GuiState

Determina se il puntatore del mouse del giocatore è attivamente premuto sul `Class.GuiObject` o meno.

GuiObject.InputSink

Determina se il `Class.GuiButton` può essere interagito o meno, o
se lo stato `Enum.GuiState|GuiState` del `Class.GuiObject` sta cambiando o
meno.

Su un `Class.GuiButton`:

- Quando l'impostazione `Class.GuiObject.Interactable|Interactable` sul
  `Class.GuiButton` è impostata su `false`, il `Class.GuiButton` non
  potrà più essere premuto o cliccato, e lo
  stato `Class.GuiObject.GuiState|GuiState` sarà costantemente impostato su
  `Enum.GuiState.NonInteractable|NonInteractable`.
- Quando l'impostazione `Class.GuiObject.Interactable|Interactable` sul
  `Class.GuiButton` è impostata su `true`, il `Class.GuiButton` si comporterà
  di nuovo normalmente e lo stato `Class.GuiObject.GuiState|GuiState` si
  comporterà normalmente.

Su un `Class.GuiObject`:

- Quando l'impostazione `Class.GuiObject.Interactable|Interactable` sul
  `Class.GuiButton` è impostata su `false`, lo stato
  `Class.GuiObject.GuiState|GuiState` sarà costantemente impostato su
  `Enum.GuiState.NonInteractable|NonInteractable`.
- Quando l'impostazione `Class.GuiObject.Interactable|Interactable` sul
  `Class.GuiButton` è impostata su `true`, lo stato
  `Class.GuiObject.GuiState|GuiState` si comporterà di nuovo normalmente.


GuiObject.Interactable

Determina se il `Class.GuiButton` può essere interagito o meno, o
se lo stato `Enum.GuiState|GuiState` del `Class.GuiObject` sta cambiando o
meno.


Questa proprietà controlla l'ordine di ordinamento del `Class.GuiObject` quando
si utilizza un `Class.UIGridStyleLayout` (come `Class.UIListLayout` o
`Class.UIPageLayout`) con `Class.UIGridStyleLayout.SortOrder|SortOrder`
impostato su `Enum.SortOrder.LayoutOrder`. Non ha funzionalità se l'oggetto
non ha una struttura di layout UI fraterna.

I `Class.GuiObject|GuiObjects` sono ordinati in ordine crescente dove valori
più bassi hanno priorità su valori più alti. Gli oggetti con valori uguali
ritornano all'ordine in cui sono stati aggiunti.

Se non sei sicuro di dover aggiungere un elemento tra due elementi esistenti
in futuro, è buona pratica usare multipli di `100`
(`0`, `100`, `200`, ecc.). Questo garantisce un ampio intervallo di valori
per l'ordine di layout che puoi utilizzare per elementi ordinati tra altri elementi.

Vedi anche `Class.GuiObject.ZIndex|ZIndex` che determina l'ordine di **rendering**
dell'oggetto anziché l'ordine di ordinamento.


GuiObject.LayoutOrder

Controlla l'ordine di ordinamento del `Class.GuiObject` quando usato con un
`Class.UIGridStyleLayout`.


Questo esempio dimostra come abilitare la navigazione tramite Gamepad attraverso una griglia di
`GuiObject|GUI` elementi senza dover collegare manualmente i
`Class.GuiObject.NextSelectionUp`, `Class.GuiObject.NextSelectionDown`, e
`GuiObject|NextSelectionRight`, e `Class.GuiObject.NextSelectionLeft`
proprietà per ogni elemento nella griglia.

Nota che questo campione di codice presuppone che il tuo `UIGridLayout` sia ordinato per
`Class.UIGridLayout.SortOrder|name`, dove gli elementi sono nominati in ordine numerico successivo.

Il codice si basa su questo per impostare le proprietà NextSelection per tutti
`GuiObjects` nello stesso livello del UIGridLayout. Nel nostro esempio, il
UIGridLayoutObject e gli elementi GUI all'interno della griglia sono tutti figli di un
`Frame` chiamato _"Container"_. Il codice
`Class.Instance:GetChildren()|ottiene i figli` di _"Container"_ e scorre
ogni figlio. I figli che non sono GuiObjects vengono ignorati. Per ogni elemento GUI,
il codice tenta di assegnare le proprietà NextSelection utilizzando la
seguente logica:

1. Iniziando da 1, il nome di tutti gli elementi GUI corrisponde alla loro posizione nella
   griglia
2. Sinistra: L'elemento a sinistra sarà sempre numerato 1 in meno dell'elemento corrente
3. Destra: L'elemento a destra sarà sempre numerato 1 in più dell'elemento corrente
4. Su: L'elemento sopra (su) sarà sempre il numero di GUI in una riga 1 in meno dell'elemento corrente
5. Giù: L'elemento sotto (giù) sarà sempre il numero di GUI in una riga più
   dell'elemento corrente Questa logica consente anche agli elementi GUI all'inizio e alla fine delle righe (escluso il primo e l'ultimo elemento) di avvolgersi
   alle righe successive e precedenti. Se un elemento non esiste a sinistra, a destra, sopra o sotto, il NextSelection rimarrà nil e muovere il
   selettore del Gamepad nella direzione non cambierà il GUI selezionato.

Questo esempio contiene anche codice per testare la griglia utilizzando i tasti freccia (Su,
Giù, Sinistra, Destra) della tastiera invece di un gamepad, nel caso in cui tu
non abbia un gamepad con cui testare. Questa parte di codice seleziona inizialmente l'elemento chiamato _"1"_ assegnandolo alla proprietà `Class.GuiService.SelectedObject`.


Questa proprietà imposta il `Class.GuiObject` selezionato quando l'utente
muove il selettore del [gamepad](/input/gamepad) verso il basso. Se questa proprietà
è vuota, muovendo il gamepad verso il basso non cambierà la GUI selezionata.

Muovendo il selettore del gamepad verso il basso si imposta il
`Class.GuiService.SelectedObject` su questo oggetto a meno che la GUI non sia
`Class.GuiObject.Selectable|Selectable`. Nota che questa proprietà può essere
impostata su un elemento GUI anche se non è
`Class.GuiObject.Selectable|Selectable`, quindi dovresti assicurarti che il
valore della proprietà selezionabile di una GUI corrisponda al tuo comportamento atteso.

Vedi anche `Class.GuiObject.NextSelectionUp|NextSelectionUp`,
`Class.GuiObject.NextSelectionLeft|NextSelectionLeft`, e
`Class.GuiObject.NextSelectionRight|NextSelectionRight`.


GuiObject.NextSelectionDown

Imposta il `Class.GuiObject` che sarà selezionato quando il selettore
 del gamepad viene spostato verso il basso.


Questa proprietà imposta il `Class.GuiObject` selezionato quando l'utente
muove il selettore del [gamepad](/input/gamepad) verso sinistra. Se questa
proprietà è vuota, muovendo il gamepad a sinistra non cambierà la
GUI selezionata.

Muovendo il selettore del gamepad a sinistra si imposta il
`Class.GuiService.SelectedObject` su questo oggetto a meno che la GUI non sia
`Class.GuiObject.Selectable|Selectable`. Nota che questa proprietà può essere
impostata su un elemento GUI anche se non è
`Class.GuiObject.Selectable|Selectable`, quindi dovresti assicurarti che il
valore della proprietà selezionabile di una GUI corrisponda al tuo comportamento atteso.

Vedi anche `Class.GuiObject.NextSelectionUp|NextSelectionUp`,
`Class.GuiObject.NextSelectionDown|NextSelectionDown`, e
`Class.GuiObject.NextSelectionRight|NextSelectionRight`.


GuiObject.NextSelectionLeft

Imposta il `Class.GuiObject` che sarà selezionato quando il selettore
 del gamepad viene spostato verso sinistra.


Questa proprietà imposta il `Class.GuiObject` selezionato quando l'utente
muove il selettore del [gamepad](/input/gamepad) verso destra. Se questa
proprietà è vuota, muovendo il gamepad a destra non cambierà la
GUI selezionata.

Muovendo il selettore del gamepad a destra si imposta il
`Class.GuiService.SelectedObject` su questo oggetto a meno che la GUI non sia
`Class.GuiObject.Selectable|Selectable`. Nota che questa proprietà può essere
impostata su un elemento GUI anche se non è
`Class.GuiObject.Selectable|Selectable`, quindi dovresti assicurarti che il
valore della proprietà selezionabile di una GUI corrisponda al tuo comportamento atteso.

Vedi anche `Class.GuiObject.NextSelectionUp|NextSelectionUp`,
`Class.GuiObject.NextSelectionDown|NextSelectionDown`, e
`Class.GuiObject.NextSelectionLeft|NextSelectionLeft`.


GuiObject.NextSelectionRight

Imposta il `Class.GuiObject` che sarà selezionato quando il selettore
 del gamepad viene spostato a destra.


Questa proprietà imposta il `Class.GuiObject` selezionato quando l'utente
muove il selettore del [gamepad](/input/gamepad) verso l'alto. Se questa proprietà è
vuota, muovendo il gamepad verso l'alto non cambierà la GUI selezionata.

Muovendo il selettore del gamepad verso l'alto si imposta il
`Class.GuiService.SelectedObject` su questo oggetto a meno che la GUI non sia
`Class.GuiObject.Selectable|Selectable`. Nota che questa proprietà può essere
impostata su un elemento GUI anche se non è
`Class.GuiObject.Selectable|Selectable`, quindi dovresti assicurarti che il
valore della proprietà selezionabile di una GUI corrisponda al tuo comportamento atteso.

Vedi anche `Class.GuiObject.NextSelectionDown|NextSelectionDown`,
`Class.GuiObject.NextSelectionLeft|NextSelectionLeft`,
`Class.GuiObject.NextSelectionRight|NextSelectionRight`.


GuiObject.NextSelectionUp

Imposta il `Class.GuiObject` che sarà selezionato quando il selettore
 del gamepad viene spostato verso l'alto.


Questa proprietà determina la posizione pixel e scalare del `Class.GuiObject`
utilizzando un `Datatype.UDim2`. La posizione è centrata attorno al
`Class.GuiObject.AnchorPoint` dell'oggetto.

La posizione scalare è relativa alle dimensioni dell'elemento GUI genitore, se
e presente.

Le porzioni pixel del valore `Datatype.UDim2` sono le stesse indipendentemente
dalle dimensioni della GUI genitore. I valori rappresentano la posizione dell'oggetto
in pixel. La reale posizione pixel di un oggetto può essere letta dalla
proprietà `Class.GuiBase2d.AbsolutePosition`.


GuiObject.Position

Determina la posizione pixel e scalare del `Class.GuiObject`.


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

/reference/engine/classes/CanvasGroup.yaml