`Class.TextChannelWindow` è un `Class.GuiObject` che visualizza i messaggi di chat testuale
in esperienza da un `Class.TextChannel` collegato. Posizionalo sotto un
`Class.ScreenGui` o un altro discendente di `Class.LayerCollector` per visualizzare la chat
in una posizione e layout personalizzati.

Imposta `Class.TextChannelWindow.Target|Target` su un `Class.TextChannel` per scegliere
quali messaggi del canale mostra la finestra. La finestra si registra con
`Class.TextChatService` quando viene aggiunta al modello dati.

Le proprietà impostate su `Class.ChatWindowConfiguration` non si applicano a questa finestra.

Figli accettati: `Class.UICorner`, `Class.UIAspectRatioConstraint`,
`Class.UISizeConstraint`, e script (`Class.LocalScript`, `Class.Script`,
`Class.ModuleScript`); altri tipi di figli vengono rifiutati.


TextChannelWindow

Un riferimento al `Class.TextChannel` i cui messaggi questa finestra visualizza.
Quando impostato, la finestra mostra i messaggi dal canale specificato. Impostare
questa proprietà su `nil` disconnette la finestra da qualsiasi canale, quindi non
visualizza messaggi.

Il valore predefinito è `nil` (nessun canale collegato).

TextChannelWindow.Target

Mostra il canale RBXGeneral in una finestra personalizzata con un font non predefinito. Incolla
in uno LocalScript.


Font utilizzato per visualizzare i messaggi di questa finestra e la sua barra di input. Applicato solo
quando `Class.TextChannelWindow.UseDefaultFont` è `false`.


TextChannelWindow.FontFace

Font utilizzato per visualizzare il testo in questa finestra.


Quando `true` (predefinito), la finestra utilizza il font predefinito della piattaforma live.
Quando `false`, la finestra utilizza `Class.TextChannelWindow.FontFace|FontFace`.


TextChannelWindow.UseDefaultFont

Se questa finestra utilizza il font predefinito della piattaforma live.


`Class.GuiObject` è una classe astratta (proprio come `Class.BasePart`) per un oggetto
interfaccia utente 2D. Definisce tutte le proprietà relative alla visualizzazione
di un oggetto dell'interfaccia grafica (GUI) come `Class.GuiObject.Size|Size`
e `Class.GuiObject.Position|Position`. Ha anche alcune proprietà utili in 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 utilizzare una struttura
layout come [list/flex](/ui/list-flex-layouts) o
[grid](/ui/grid-table-layouts), e puoi stilizzarli oltre alle loro
proprietà principali tramite
[appearance modifiers](/ui/appearance-modifiers).

Sebbene sia possibile rilevare eventi 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/premute.

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
the UDim2 da cui 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 sottostante presuppone che sia all'interno di un GuiObject come un `TextButton`, e
che la proprietà `Class.GuiObject.Draggable` sia impostata su true. Stampa
gli 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 stamperebbe: 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 **X** del mouse in pixel, relativa all'angolo in alto a sinistra
dello schermo.

La posizione **Y** del mouse in pixel, relativa all'angolo in alto a sinistra
dello schermo.

Attivato quando un giocatore smette di trascinare l'oggetto.

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

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


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

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

Questo evento si attiverà 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 di input`, e
`Class.InputObject.Position|coordinate dello schermo dell'input`.

Attivato quando un utente inizia a interagire tramite un dispositivo di interfaccia
Umano-Computer (pulsante del mouse giù, inizio tocco, pulsante della tastiera giù, ecc).

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

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


Questo evento si attiva quando un utente cambia il modo in cui interagisce tramite un
 dispositivo di interfaccia Umano-Computer (pulsante del mouse giù, inizio tocco, pulsante della tastiera giù,
etc).

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

Questo evento si attiverà 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 interagisce tramite un dispositivo di
interfaccia Umano-Computer (pulsante del mouse giù, inizio tocco, pulsante della tastiera giù,
etc).

Il seguente esempio dimostra uno dei molti casi d'uso per gestire l'input dell'utente
in base al tipo di InputEnded.

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


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

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

Questo evento si attiverà 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
Umano-Computer (pulsante del mouse giù, inizio tocco, pulsante della tastiera giù, 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 mouse in un
 elemento `Class.GuiObject`.

Si prega di non fare affidamento sugli argomenti `x` e `y` passati da questo evento come un
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 tramite
lo stesso bordo - in particolare quando il mouse entra rapidamente nell'elemento. Questo
è dovuto al fatto che le coordinate indicano la posizione del mouse quando
l'evento si attiva 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 tenere traccia di quando il mouse di un utente esce da 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 **X** del mouse in pixel, relativa all'angolo in alto a sinistra
dello schermo.

La coordinata **Y** del mouse in pixel, relativa all'angolo in alto a sinistra
dello schermo.

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

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

Si prega di non fare affidamento sugli argomenti `x` e `y` passati da questo evento come un
modo infallibile per determinare dove si trova il mouse dell'utente quando esce da una
GUI. Queste coordinate possono variare anche quando il mouse esce dalla GUI tramite
lo stesso bordo - in particolare quando il mouse esce rapidamente dall'elemento. Questo
è dovuto al fatto che le coordinate indicano la posizione del mouse quando
l'evento si attiva piuttosto che il momento esatto in cui il mouse esce dalla 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 mouse fuori da un elemento GUI.

Si attiva ogni volta che un utente muove il mouse mentre si trova all'interno di un
`Class.GuiObject`. È simile a `Class.Mouse.Move`, che
si attiva indipendentemente dal fatto che il mouse dell'utente sia sopra un elemento GUI.

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

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

Il codice qui sotto dimostra come determinare l'offset `Datatype.Vector2`
del mouse dell'utente rispetto a un elemento GUI.
`Class.GuiObject.AbsolutePosition|AbsolutePosition` è misurato all'interno del
margine GUI dello schermo, mentre gli argomenti `x` e `y` di questo evento sono
coordinate dello schermo che lo includono, quindi il campione chiama
`Class.GuiService:GetGuiInset()|GetGuiInset()` per riconciliare i due spazi
invece di assumere una dimensione fissa del margine.

```lua
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)
```
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 sposta il 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
quando il mouse è sopra un elemento `Class.GuiObject`. È simile a
`Class.Mouse.WheelBackward`, che si attiva indipendentemente dal fatto che il mouse dell'utente
sia sopra un elemento GUI.

Questo evento si attiva semplicemente come indicatore del movimento all'indietro della rotella.
Questo significa che gli argomenti delle coordinate del mouse `x` e `y` non cambiano come
risultato di questo evento. Queste coordinate cambiano solo quando il mouse
si muove, il che può essere tracciato 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 quando il mouse è sopra un
elemento GUI.

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

Questo evento si attiva semplicemente come indicatore del movimento in avanti della rotella.
Questo significa che le coordinate del mouse **X** e **Y** non cambiano come risultato di
questo evento. Queste coordinate cambiano solo quando il mouse si muove, il che può essere
tracciato 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 quando il mouse è sopra
un elemento GUI.

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

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


Questo evento si attiva quando il selettore del gamepad inizia a mettere a fuoco il
`Class.GuiObject`.

Se desideri controllare quando il selettore del gamepad smette di mettere a fuoco l'elemento GUI,
puoi utilizzare l'evento `Class.GuiObject.SelectionLost`.

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

GuiObject.SelectionGained

Attivato quando il GuiObject è messo a fuoco con il 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 un figlio di _gui_.


Questo evento si attiva quando il selettore del gamepad smette di mettere a fuoco il
`Class.GuiObject`.

Se desideri controllare quando il selettore del gamepad inizia a mettere a fuoco l'elemento GUI,
puoi utilizzare l'evento `Class.GuiObject.SelectionGained`.

Quando una GUI perde il focus di selezione, il valore della
proprietà `Class.GuiService.SelectionObject|SelectionObject` cambia a `nil` o
all'elemento GUI che guadagna il focus 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 mettere a fuoco il GuiObject.

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


Questo evento si attiva dopo un breve momento quando il giocatore tiene il dito
sull'elemento UI 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 sposta il dito durante il gesto, e infine `Enum.UserInputState.End`. Il ritardo è dipendente dalla piattaforma; in 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 sola volta all'inizio del gesto (dopo un breve
  ritardo)
- Cambiamento 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 premere a lungo l'elemento UI.

Questo esempio di codice è destinato ad essere posizionato in un `LocalScript` all'interno di un
`Frame` che si trova all'interno di un `Frame` esterno, o di un altro `GuiObject`. Permette al
giocatore di manipolare la posizione del frame interno muovendo il dito sul
frame esterno.


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

Questo evento si attiva con una tabella di `Datatype.Vector2` che descrive le
posizioni relative sullo 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`, ciascuno che indica la
posizione di tutte le dita coinvolte nel gesto.

totalTranslation

Indica quanto lontano è andato il gesto di pan dal suo punto di partenza.

velocity

Indica quanto velocemente viene eseguito il gesto in ciascuna
dimensione.

Indica lo `Enum.UserInputState` del gesto.

Si attiva quando il giocatore muove il dito 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`. Permette 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 fare un gesto di pizzicamento o tiraggio
sull'elemento UI utilizzando un dispositivo abilitato al tocco. Un **pizzicamento**
si verifica quando due o più dita si avvicinano, e un **tiraggio**
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 UI 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 sullo 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`. Si dovrebbe notare 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 sta avvenendo il gesto di pizzicamento.

Si attiva 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`. Permette 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 fare un gesto di pizzicamento o tiraggio
sull'elemento UI utilizzando un dispositivo abilitato al tocco. La rotazione si verifica
quando l'angolo della linea tra due dita cambia. Questo evento si attiva
in concomitanza con `Class.GuiObject.TouchPan`. Questo evento è utile per
consentire al giocatore di manipolare la rotazione degli elementi UI sullo
schermo.

Questo evento si attiva con una tabella di `Datatype.Vector2` che descrive le
posizioni relative sullo 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

rotation

Un float che indica quanto è andata la rotazione dall'inizio
del gesto.

Un float che indica quanto velocemente viene eseguito il gesto.

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

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


Questo evento si attiva quando il giocatore esegue un gesto di scorrimento sull'elemento UI
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 sono spesso utilizzati per cambiare schede nelle UI 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).

Si attiva 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 UI
utilizzando un dispositivo abilitato al tocco. Un tocco è un rapido contatto 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.

Si attiva 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. Stampa anche se il tween verrà eseguito.


Sposta senza soluzione di continuità un'interfaccia utente in una nuova posizione `Datatype.UDim2` nel tempo specificato utilizzando la `Enum.EasingDirection` e `Enum.EasingStyle` specificati.
Questo metodo genera un errore se `easingStyle` è `Enum.EasingStyle.Bezier` o `Enum.EasingStyle.Spring`.

Questa funzione restituirà se il tween verrà riprodotto. Non verrà riprodotto se un altro tween sta agendo sull'`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 facilitare la GUI verso la _endPosition_.

easingStyle

Lo stile con cui facilitare la GUI verso la _endPosition_.

time

Quanto tempo, in secondi, dovrebbe impiegare il tween per completarsi.

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 una nuova `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 è metà della dimensione del `GuiObject`
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 senza soluzione di continuità un `Class.GuiObject` a un nuovo `Datatype.UDim2` nel tempo specificato utilizzando la `Enum.EasingDirection` e `Enum.EasingStyle` specificati. Questo metodo genera un errore se `easingStyle` è `Enum.EasingStyle.Bezier` o `Enum.EasingStyle.Spring`.

Questa funzione restituirà se il tween verrà riprodotto. Normalmente questo restituirà sempre `true`, ma restituirà `false` se un altro tween è attivo e l'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 facilitare la GUI verso la _endSize_.

Lo stile con cui facilitare la GUI verso la _endSize_.

Ridimensiona dolcemente un `Class.GuiObject` a una nuova `Datatype.UDim2`.

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


Ridimensiona e sposta senza soluzione di continuità un'interfaccia utente a una nuova dimensione `Datatype.UDim2` e posizione nel tempo specificato utilizzando la `Enum.EasingDirection` e `Enum.EasingStyle` specificati. Questo metodo genera un errore se `easingStyle` è `Enum.EasingStyle.Bezier` o `Enum.EasingStyle.Spring`.

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

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


GuiObject:TweenSizeAndPosition

La direzione in cui facilitare la GUI verso la _endSize_ e
_endPosition_.

Lo stile con cui facilitare la GUI verso la _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` affonderà l'input nello
spazio 3D, come i 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` viene attivato
(`Class.GuiButton.AutoButtonColor|AutoButtonColor` funzionerà comunque 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 UI affonda l'input.

Questo esempio di codice sposta un elemento UI sui 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 uno ScreenGui.


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

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

GuiObject.AnchorPoint

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

Il seguente script crea un frame genitore con dimensioni automatiche con
a un `UIListLayout`, quindi inserisce diversi oggetti `TextLabel`
con dimensioni automatiche. Nota come il `UIListLayout` genitore si ridimensiona automaticamente per adattarsi al
contenuto dei suoi figli e le etichette si ridimensionano automaticamente per adattarsi al loro contenuto testuale.
Questo script può essere genitore di un `ScreenGui`.


Questa proprietà viene utilizzata per dimensionare automaticamente gli oggetti UI
padre in base alla dimensione dei suoi discendenti. Puoi utilizzare questa proprietà
per aggiungere dinamicamente testo e altri contenuti a un oggetto UI in fase di modifica o
esecuzione, 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 a seconda del suo
contenuto figlio.

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

GuiObject.AutomaticSize

Determina se il ridimensionamento avviene in base al contenuto figlio.

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

GuiObject.BackgroundColor

Questo esempio di codice fa sì che un Frame genitore attraversi tutti i colori dell'
arcobaleno utilizzando 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`.
Non determina, tuttavia, la trasparenza del testo se la GUI è un `Class.TextBox`, `Class.TextButton`, o
`Class.TextLabel`; la trasparenza del testo è determinata
`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 si evidenzi quando l'utente passa il mouse sopra l'elemento.


Determina il colore del bordo rettangolare del `Class.GuiObject` (noto anche
come colore del tratto). Questo è separato dal colore di sfondo dell'oggetto
`Class.GuiObject.BackgroundColor3`. Non sarai in grado di vedere il
bordo dell'oggetto se la sua 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'enum 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. Impostare questo su 0 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à (renderà
invisibile) qualsiasi porzione di elementi GUI discendenti che altrimenti
verrebbero renderizzati al di fuori dei limiti del rettangolo.

#### Comportamento di Rotazione

Quando `Class.StarterGui.ClipsDescendantsSupportsRotation` è abilitato,
il ritaglio funziona correttamente per forme ruotate. Tuttavia, il ritaglio **da**
forme ruotate (quando il genitore del ritaglio stesso è ruotato) o da angoli
arrotondati (`Class.UICorner`) non è supportato.

Quando `Class.StarterGui.ClipsDescendantsSupportsRotation` **non** è
abilitato e questo `Class.GuiObject` o qualsiasi antenato `Class.GuiObject` ha un
**non-zero** `Class.GuiObject.Rotation|Rotation`, questa proprietà è
**ignorata** e gli elementi GUI discendenti verranno renderizzati indipendentemente dal valore
di questa proprietà.

GuiObject.ClipsDescendants

Determina se i discendenti `Class.GuiObject|GuiObjects` al di fuori dei
limiti di un elemento GUI padre devono essere renderizzati.

Questo indica se un `Class.GuiObject` (e i suoi discendenti) possono essere
trascinati sullo schermo.

GuiObject.Draggable

Determina se un `Class.GuiObject` (e i suoi discendenti) possono essere
trascinati sullo schermo.

Quando il dito del giocatore viene toccato e tenuto sul
`Class.GuiObject`, lo stato `Class.GuiObject.GuiState|GuiState` del
`Class.GuiObject` sarà 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` sarà impostato
su `Enum.GuiState.Idle|Idle`, e quando
`Class.GuiObject.Interactable|Interactable` è disattivato sul
`Class.GuiObject`, lo `Class.GuiState` del `Class.GuiObject` sarà
impostato su `Enum.GuiState.NonInteractable|NonInteractable`.

GuiObject.GuiState

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

Controlla se e a che grado il `Class.GuiObject` affonda l'input
che avviene su di esso, utilizzando `Enum.InputSink`. Affondare l'input impedisce che
passi attraverso oggetti dietro l'elemento, inclusi oggetti 3D
nel mondo come quelli con un `Class.ClickDetector` o
`Class.DragDetector`. Di default è impostato su `Enum.InputSink.None`, tranne che per
oggetti `Class.GuiButton` (`Class.ImageButton` e `Class.TextButton`),
che di default è impostato su `Enum.InputSink.Activate`.

- `Enum.InputSink.None` — l'oggetto non affonda l'input da solo.
- `Enum.InputSink.Activate` — l'oggetto affonda l'input di pressione e rilascio
del pulsante del mouse e del tocco utilizzato per attivarlo, ma lascia passare
altro input (come il movimento del mouse).
- `Enum.InputSink.All` — l'oggetto affonda tutto l'input che avviene su di esso.

Questa proprietà è un successore più granulare della proprietà booleana
`Class.GuiObject.Active|Active`, che può solo affondare tutto l'input o
nessuno. Gli eventi `Class.GuiObject.InputBegan|InputBegan`,
`Class.GuiObject.InputChanged|InputChanged`, e
`Class.GuiObject.InputEnded|InputEnded` vengono attivati indipendentemente dal valore
di questa proprietà.

GuiObject.InputSink

Controlla se e come il `Class.GuiObject` affonda l'input che avviene
su di esso.

Determina se il `Class.GuiButton` può essere interagito o meno, o
se lo `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
  `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à
  normalmente di nuovo e lo `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
  `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
  `Class.GuiObject.GuiState|GuiState` si comporterà normalmente di nuovo.

GuiObject.Interactable

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

Questa proprietà controlla l'ordine di ordinamento del `Class.GuiObject` quando
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 sorella.

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

Se non sei sicuro se avrai bisogno di aggiungere un elemento tra due elementi
esistenti in futuro, è una buona pratica utilizzare multipli di `100`
(`0`, `100`, `200`, ecc.). Questo assicura 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 invece dell'ordine di ordinamento.

GuiObject.LayoutOrder

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

Questo esempio dimostra come abilitare la navigazione con il 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 esempio di codice presume 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 cicla
attraverso 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. Partendo 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 GUIs in una riga 1 in meno dell'elemento corrente
5. Giù: L'elemento sotto (giù) sarà sempre il numero di GUIs in una riga più
   dell'elemento corrente Questa logica consente anche agli elementi GUI all'inizio e alla fine delle righe (escludendo il primo e l'ultimo elemento) di avvolgersi
   alle righe successive e precedenti. Se un elemento non esiste a sinistra, destra, sopra o giù, il NextSelection rimarrà nil e muovere il
   selettore del Gamepad in quella direzione non cambierà il GUI selezionato.

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


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

Spostare il selettore del gamepad verso il basso 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 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 sposta il
[gamepad](/input/gamepad) selettore a sinistra. Se questa
proprietà è vuota, spostare il gamepad a sinistra non cambierà la
GUI selezionata.

Spostare il selettore del gamepad a sinistra 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 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 a sinistra.

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

Spostare il selettore del gamepad a destra 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 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.

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

/reference/engine/classes/TextChannelWindow.yaml

Riepilogo