`Class.TextChannelWindow` é um `Class.GuiObject` que renderiza mensagens de chat de texto
no experimento a partir de um `Class.TextChannel` vinculado. Coloque-o sob um
`Class.ScreenGui` ou outro descendente de `Class.LayerCollector` para exibir o chat
em um local e layout personalizados.

Defina `Class.TextChannelWindow.Target|Target` para um `Class.TextChannel` para escolher
quais mensagens de canal a janela exibe. A janela se registra no
`Class.TextChatService` quando adicionada ao modelo de dados.

Propriedades definidas em `Class.ChatWindowConfiguration` não se aplicam a esta janela.

Filhos aceitos: `Class.UICorner`, `Class.UIAspectRatioConstraint`,
`Class.UISizeConstraint`, e scripts (`Class.LocalScript`, `Class.Script`,
`Class.ModuleScript`); outros tipos de filhos são rejeitados.


TextChannelWindow

Uma referência ao `Class.TextChannel` cujas mensagens esta janela renderiza.
Quando definido, a janela mostra mensagens do canal especificado. Definir
esta propriedade como `nil` desconecta a janela de qualquer canal, de modo que
não exibe mensagens.

O valor padrão é `nil` (nenhum canal vinculado).

TextChannelWindow.Target

Mostra o canal RBXGeneral em uma janela personalizada com uma fonte não padrão. Cole
em um LocalScript.


Fonte usada para renderizar as mensagens desta janela e sua barra de entrada. Aplicada apenas
quando `Class.TextChannelWindow.UseDefaultFont` é `false`.


TextChannelWindow.FontFace

Fonte usada para renderizar texto nesta janela.


Quando `true` (padrão), a janela usa a fonte padrão da plataforma ao vivo.
Quando `false`, a janela usa `Class.TextChannelWindow.FontFace|FontFace`.


TextChannelWindow.UseDefaultFont

Se esta janela usa a fonte padrão da plataforma ao vivo.


`Class.GuiObject` é uma classe abstrata (muito parecida com `Class.BasePart`) para um objeto de interface de usuário 2D. Ela define todas as propriedades relacionadas à exibição de um objeto de interface gráfica (GUI), como `Class.GuiObject.Size|Size` e `Class.GuiObject.Position|Position`. Também possui algumas propriedades úteis de leitura, como `Class.GuiObject.AbsolutePosition|AbsolutePosition`, `Class.GuiObject.AbsoluteSize|AbsoluteSize` e `Class.GuiObject.AbsoluteRotation|AbsoluteRotation`.

Para manipular o layout de objetos GUI de maneiras especiais, você pode usar uma estrutura de layout como [list/flex](/ui/list-flex-layouts) ou [grid](/ui/grid-table-layouts), e pode estilizar além de suas propriedades principais através de [modificadores de aparência](/ui/appearance-modifiers).

Embora seja possível detectar eventos de botão do mouse em qualquer objeto GUI usando `Class.GuiObject.InputBegan|InputBegan` e `Class.GuiObject.InputEnded|InputEnded`, apenas `Class.ImageButton` e `Class.TextButton` possuem eventos dedicados convenientes, como `Class.TextButton.Activated|Activated`, para detectar cliques/pressões.

O exemplo abaixo assume que está dentro de um GuiObject, como um `TextButton`, e
que a propriedade `Class.GuiObject.Draggable` está definida como verdadeira. Ele imprimirá
o UDim2 de onde o jogador começou a arrastar o objeto.

Este evento é disparado quando um jogador começa a arrastar o objeto.

Veja também `Class.GuiObject.DragStopped`.

GuiObject.DragBegin

initialPosition

Um valor `Datatype.UDim2` da posição do `Class.GuiObject` antes de qualquer operação de arrasto começar.

Disparado quando um jogador começa a arrastar o objeto.

O exemplo abaixo assume que está dentro de um GuiObject como um `TextButton`, e
que a propriedade `Class.GuiObject.Draggable` está definida como verdadeira. Ele imprimirá
o X e Y de onde o jogador parou de arrastar a GUI. Por exemplo, se o
jogador parar de arrastar o objeto em 189, 180, o abaixo imprimirá O
jogador parou de arrastar o GuiObject em (189, 180)


Este evento é disparado quando um jogador para de arrastar o objeto.

Veja também `Class.GuiObject.DragBegin`.

GuiObject.DragStopped

A localização da tela do mouse **X** em pixels, relativa ao canto superior esquerdo da tela.

A localização da tela do mouse **Y** em pixels, relativa ao canto superior esquerdo da tela.

Disparado quando um jogador para de arrastar o objeto.

O seguinte exemplo demonstra um dos muitos exemplos de uso de manipulação de entrada do usuário
InputBegan dependendo do seu tipo.

Para que isso funcione como esperado, deve ser colocado em um `LocalScript`
e ser um filho de _gui_.


Este evento é disparado quando um usuário começa a interagir com o `Class.GuiObject` via um dispositivo de Interface Humano-Computador (botão do mouse pressionado, toque iniciado, botão do teclado pressionado, etc).

O `Class.UserInputService` tem um evento com nome semelhante que não é restrito a um elemento de UI específico: `Class.UserInputService.InputBegan`.

Este evento sempre será disparado, independentemente do estado do jogo.

Veja também `Class.GuiObject.InputEnded` e `Class.GuiObject.InputChanged`.

GuiObject.InputBegan

input

Um `Class.InputObject`, que contém dados úteis para consultar a entrada do usuário, como o `Enum.UserInputType|tipo de entrada`, `Enum.UserInputState|estado da entrada` e `Class.InputObject.Position|coordenadas de tela da entrada`.

Disparado quando um usuário começa a interagir via um dispositivo de Interface Humano-Computador (botão do mouse pressionado, toque iniciado, botão do teclado pressionado, etc).

O exemplo a seguir demonstra um dos muitos exemplos de uso de manipulação de entrada do usuário
InputChanged dependendo do seu tipo.

Para que isso funcione como esperado, deve ser colocado em um `LocalScript`
e um filho de _gui_.


Este evento é disparado quando um usuário muda como está interagindo via um dispositivo de Interface Humano-Computador (botão do mouse pressionado, toque iniciado, botão do teclado pressionado, etc).

O `Class.UserInputService` tem um evento com nome semelhante que não é restrito a um elemento de UI específico: `Class.UserInputService.InputChanged`.

Este evento sempre será disparado, independentemente do estado do jogo.

Veja também `Class.GuiObject.InputBegan` e `Class.GuiObject.InputEnded`.

GuiObject.InputChanged

Disparado quando um usuário muda como está interagindo via um dispositivo de Interface Humano-Computador (botão do mouse pressionado, toque iniciado, botão do teclado pressionado, etc).

O seguinte exemplo demonstra um dos muitos exemplos de uso de manipulação de entrada do usuário
InputEnded dependendo do seu tipo.

Para que isso funcione como esperado, deve ser colocado em um `LocalScript`
e um filho de _gui_.


O evento InputEnded é disparado quando um usuário para de interagir via um dispositivo de Interface Humano-Computador (botão do mouse pressionado, toque iniciado, botão do teclado pressionado, etc).

O `Class.UserInputService` tem um evento com nome semelhante que não é restrito a um elemento de UI específico: `Class.UserInputService.InputEnded`.

Este evento sempre será disparado, independentemente do estado do jogo.

Veja também `Class.GuiObject.InputBegan` e `Class.GuiObject.InputChanged`.

GuiObject.InputEnded

Um `Class.InputObject`, que contém dados úteis para consultar a entrada do usuário, como o `Enum.UserInputType`, `Enum.UserInputState` e `Class.InputObject.Position`.

Disparado quando um usuário para de interagir via um dispositivo de Interface Humano-Computador (botão do mouse pressionado, toque iniciado, botão do teclado pressionado, etc).

O seguinte exemplo imprime a localização do mouse, em pixels, quando ele entra no elemento GUI.


O evento MouseEnter dispara quando um usuário move o mouse para dentro de um elemento `Class.GuiObject`.

Por favor, não confie nos argumentos `x` e `y` passados por este evento como uma maneira infalível de determinar onde está o mouse do usuário quando ele entra em uma GUI. Essas coordenadas podem variar mesmo quando o mouse entra na GUI pela mesma borda - particularmente quando o mouse entra rapidamente no elemento. Isso se deve ao fato de que as coordenadas indicam a posição do mouse quando o evento dispara, em vez do momento exato em que o mouse entra na GUI.

Este evento dispara mesmo quando o elemento GUI é renderizado abaixo de outro elemento.

Se você gostaria de rastrear quando o mouse de um usuário sai de um elemento GUI, você pode usar o evento `Class.GuiObject.MouseLeave`.

##### Veja Também

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

GuiObject.MouseEnter

A coordenada de tela do mouse **X** em pixels, relativa ao canto superior esquerdo da tela.

A coordenada de tela do mouse **Y** em pixels, relativa ao canto superior esquerdo da tela.

Dispara quando um usuário move o mouse para dentro de um elemento GUI.

O evento MouseLeave dispara quando um usuário move o mouse para fora de um elemento `Class.GuiObject`.

Por favor, não confie nos argumentos `x` e `y` passados por este evento como uma maneira infalível de determinar onde está o mouse do usuário quando ele sai de uma GUI. Essas coordenadas podem variar mesmo quando o mouse sai da GUI pela mesma borda - particularmente quando o mouse sai rapidamente do elemento. Isso se deve ao fato de que as coordenadas indicam a posição do mouse quando o evento dispara, em vez do momento exato em que o mouse sai da GUI.

Este evento dispara mesmo quando o elemento GUI é renderizado abaixo de outro elemento.

##### Veja Também

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

GuiObject.MouseLeave

Dispara quando um usuário move o mouse para fora de um elemento GUI.

Dispara sempre que um usuário move o mouse enquanto ele está dentro de um
`Class.GuiObject`. É semelhante a `Class.Mouse.Move`, que
dispara independentemente de o mouse do usuário estar sobre um elemento GUI.

Observe que este evento dispara quando a posição do mouse é atualizada, portanto,
esse evento será disparado repetidamente enquanto o mouse estiver sendo movido.

Os argumentos `x` e `y` indicam as coordenadas de tela atualizadas do
mouse do usuário em pixels. Esses podem ser úteis para determinar a
localização do mouse na GUI, na tela e a delta desde a posição anterior do mouse
se estiver sendo rastreada em uma variável global.

O código abaixo demonstra como determinar o deslocamento `Datatype.Vector2`
do mouse do usuário em relação a um elemento GUI.
`Class.GuiObject.AbsolutePosition|AbsolutePosition` é medido dentro do
inset da GUI da tela, enquanto os argumentos `x` e `y` deste evento são
coordenadas de tela que o incluem, então o exemplo chama
`Class.GuiService:GetGuiInset()|GetGuiInset()` para reconciliar os dois espaços
em vez de assumir um tamanho de inset fixo.

```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)
```
Observe que este evento pode não disparar exatamente quando o mouse do usuário
entra ou sai de um elemento GUI. Portanto, os argumentos `x` e `y` podem não
corresponder perfeitamente às coordenadas das bordas da GUI.

##### Veja Também

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


GuiObject.MouseMoved

Dispara sempre que um usuário move o mouse enquanto está dentro de um elemento GUI.

O evento WheelBackward dispara quando um usuário rola a roda do mouse para trás quando o mouse está sobre um elemento `Class.GuiObject`. É semelhante a `Class.Mouse.WheelBackward`, que dispara independentemente de o mouse do usuário estar sobre um elemento GUI.

Este evento dispara meramente como um indicador do movimento para trás da roda. Isso significa que os argumentos de coordenadas do mouse **x** e **y** não mudam como resultado deste evento. Essas coordenadas só mudam quando o mouse se move, o que pode ser rastreado pelo evento `Class.GuiObject.MouseMoved`.

##### Veja Também

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

GuiObject.MouseWheelBackward

Dispara quando um usuário rola a roda do mouse para trás quando o mouse está sobre um elemento GUI.

O evento WheelForward dispara quando um usuário rola a roda do mouse para frente quando o mouse está sobre um elemento `Class.GuiObject`. É semelhante a `Class.Mouse.WheelForward`, que dispara independentemente de o mouse do usuário estar sobre um elemento GUI.

Este evento dispara meramente como um indicador do movimento para frente da roda. Isso significa que os argumentos de coordenadas do mouse **X** e **Y** não mudam como resultado deste evento. Essas coordenadas só mudam quando o mouse se move, o que pode ser rastreado pelo evento `Class.GuiObject.MouseMoved`.

##### Veja Também

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

GuiObject.MouseWheelForward

Dispara quando um usuário rola a roda do mouse para frente quando o mouse está sobre um elemento GUI.

O seguinte exemplo imprime uma mensagem quando o usuário seleciona o objeto com um
gamepad.

Para que isso funcione como esperado, deve ser colocado em um `LocalScript`
e um filho de _gui_.


Este evento é disparado quando o seletor do Gamepad começa a focar no `Class.GuiObject`.

Se você quiser verificar quando o seletor do Gamepad para de focar no elemento GUI, pode usar o evento `Class.GuiObject.SelectionLost`.

Quando uma GUI ganha foco de seleção, o valor da propriedade `Class.GuiService.SelectedObject|SelectedObject` também muda para aquele que ganha a seleção. Para determinar qual GUI ganhou a seleção, verifique o valor desta propriedade.

GuiObject.SelectionGained

Disparado quando o GuiObject está sendo focado pelo seletor do Gamepad.

O seguinte exemplo imprime uma mensagem quando o elemento perde o foco em
um controle de jogo.

Para que isso funcione como esperado, deve ser colocado em um `LocalScript`
e ser um filho de _gui_.


Este evento é disparado quando o seletor do Gamepad para de focar no `Class.GuiObject`.

Se você quiser verificar quando o seletor do Gamepad começa a focar no elemento GUI, pode usar o evento `Class.GuiObject.SelectionGained`.

Quando uma GUI perde o foco de seleção, o valor da propriedade `Class.GuiService.SelectionObject|SelectionObject` muda para `nil` ou para o elemento GUI que ganha foco de seleção. Para determinar qual GUI ganhou a seleção, ou se nenhuma GUI está selecionada, verifique o valor desta propriedade.

GuiObject.SelectionLost

Disparado quando o seletor do Gamepad para de focar no GuiObject.

Este exemplo de código permite que o jogador manipule a posição na tela de algum
elemento da UI, como um `Frame`, segurando o elemento da UI por um breve
momento. Em seguida, o jogador move o dedo e solta. Durante o gesto,
o Frame é colorido de azul com um contorno branco.


Este evento dispara após um breve momento quando o jogador mantém o dedo no elemento da UI usando um dispositivo com tela sensível ao toque. Ele dispara com uma tabela de `Datatype.Vector2` que descreve as posições de tela relativas dos dedos envolvidos no gesto. Além disso, ele dispara várias vezes: `Enum.UserInputState.Begin` após um breve atraso, `Enum.UserInputState.Change` se o jogador mover o dedo durante o gesto, e finalmente `Enum.UserInputState.End`. O atraso é dependente da plataforma; no Studio, é um pouco mais longo que um segundo.

GuiObject.TouchLongPress

touchPositions

Um array de `Datatype.Vector2` que descreve as posições **relativas** dos dedos envolvidos no gesto.

state

Um `Enum.UserInputState` que descreve o estado do gesto:

- Begin dispara uma vez no início do gesto (após o breve atraso)
- Change dispara se o jogador mover o dedo enquanto pressiona
- End dispara uma vez no final do gesto quando eles liberam o dedo.

Dispara quando o jogador começa, continua e para de pressionar longamente o elemento da UI.

Este exemplo de código deve ser colocado em um `LocalScript` dentro de um
`Frame` que está dentro de um `Frame` externo, ou outro `GuiObject`. Ele permite que o
jogador manipule a posição do frame interno movendo o dedo no
frame externo.


Este evento dispara quando o jogador move o dedo no elemento da UI usando um dispositivo com tela sensível ao toque. Ele dispara pouco antes de `Class.GuiObject.TouchSwipe` disparar, e não dispara com `Class.GuiObject.TouchTap`. Este evento é útil para permitir que o jogador manipule a posição dos elementos da UI na tela.

Este evento dispara com uma tabela de `Datatype.Vector2` que descreve as posições de tela relativas dos dedos envolvidos no gesto. Além disso, ele dispara várias vezes: `Enum.UserInputState.Begin` após um breve atraso, `Enum.UserInputState.Change` quando o jogador move o dedo durante o gesto, e finalmente com `Enum.UserInputState.End`.

GuiObject.TouchPan

Um array Luau de objetos `Datatype.Vector2`, cada um indicando a posição de todos os dedos envolvidos no gesto.

totalTranslation

Indica quão longe o gesto de pan foi do seu ponto de partida.

velocity

Indica quão rapidamente o gesto está sendo realizado em cada dimensão.

Dispara quando o jogador move o dedo no elemento da UI.

Este exemplo de código é destinado a um `LocalScript` dentro de um `Frame` interno que está
dentro de um `Frame` externo, ou outro `GuiObject`. Ele permite que o jogador escale
o frame interno realizando um gesto de `Class.GuiObject.TouchPinch` no
frame externo.


Este evento é acionado quando o jogador usa dois dedos para fazer um gesto de pinça ou puxar no elemento da interface do usuário usando um dispositivo com tela sensível ao toque. Uma **pinça** acontece quando dois ou mais dedos se movem mais perto um do outro, e um **puxar** acontece quando eles se afastam. Este evento é acionado em conjunto com `Class.GuiObject.TouchPan`. Este evento é útil para permitir que o jogador manipule a escala (tamanho) dos elementos da interface do usuário na tela, e é mais frequentemente usado para recursos de zoom.

Este evento é acionado com uma tabela de `Datatype.Vector2` que descreve as posições relativas na tela dos dedos envolvidos no gesto. Além disso, ele é acionado várias vezes: `Enum.UserInputState.Begin` após um breve atraso, `Enum.UserInputState.Change` quando o jogador move um dedo durante o gesto, e finalmente com `Enum.UserInputState.End`. Deve-se notar que a escala deve ser usada **multiplicativamente**.

GuiObject.TouchPinch

Um array Luau de objetos `Datatype.Vector2`, cada um indicando a posição de todos os dedos envolvidos no gesto de pinça.

scale

Um float que indica a diferença desde o início do gesto de pinça.

Um float indicando quão rapidamente o gesto de pinça está acontecendo.

Dispara quando o jogador realiza um gesto de pinça ou puxar usando dois dedos no elemento da UI.

Este exemplo de código é destinado a um `LocalScript` dentro de um `Frame` interno que está
inside de um `Frame` externo, ou outro `GuiObject`. Ele permite que o jogador gire
o frame interno realizando um gesto `Class.GuiObject.TouchRotate` no
frame externo.


Este evento é acionado quando o jogador usa dois dedos para fazer um gesto de rotação no elemento da interface do usuário usando um dispositivo com tela sensível ao toque. A rotação ocorre quando o ângulo da linha entre dois dedos muda. Este evento é acionado em conjunto com `Class.GuiObject.TouchPan`. Este evento é útil para permitir que o jogador manipule a rotação dos elementos da interface do usuário na tela.

Este evento é acionado com uma tabela de `Datatype.Vector2` que descreve as posições relativas na tela dos dedos envolvidos no gesto. Além disso, ele é acionado várias vezes: `Enum.UserInputState.Begin` após um breve atraso, `Enum.UserInputState.Change` quando o jogador move um dedo durante o gesto, e finalmente com `Enum.UserInputState.End`.

GuiObject.TouchRotate

rotation

Um float indicando quanto a rotação mudou desde o início do gesto.

Um float que indica quão rapidamente o gesto está sendo realizado.

Aciona quando o jogador realiza um gesto de rotação usando dois dedos no elemento da interface do usuário.

Este exemplo de código fará com que um `Frame` (ou outro `GuiObject`) salte quando um gesto de
arrasto for realizado em um dispositivo com tela sensível ao toque (ou no emulador do Studio).
Arrastos horizontais mudarão o matiz do
`Class.GuiObject.BackgroundColor3`, enquanto arrastos verticais mudarão a
saturação.


Este evento é acionado quando o jogador realiza um gesto de deslizar no elemento da interface do usuário usando um dispositivo com tela sensível ao toque. Ele é acionado com a direção do gesto (Cima, Baixo, Esquerda ou Direita) e o número de pontos de toque envolvidos no gesto. Gestos de deslizar são frequentemente usados para mudar abas em interfaces móveis.

GuiObject.TouchSwipe

swipeDirection

Um `Enum.SwipeDirection` indicando a direção do gesto de deslizar (Cima, Baixo, Esquerda ou Direita).

numberOfTouches

O número de pontos de toque envolvidos no gesto (geralmente 1).

Aciona quando o jogador realiza um gesto de deslizar no elemento da interface do usuário.

Este exemplo de código alternará o `Class.GuiObject.BackgroundTransparency` de um
elemento UI, como um `Frame`, quando ele for tocado em um dispositivo com tela sensível ao toque.

Este evento é acionado quando o jogador realiza um gesto de toque no elemento da interface do usuário usando um dispositivo com tela sensível ao toque. Um toque é um toque rápido e único sem qualquer movimento envolvido (um pressionar mais longo acionaria `Class.GuiObject.TouchLongPress`, e mover durante o toque acionaria `Class.GuiObject.TouchPan` e/ou `Class.GuiObject.TouchSwipe`). Ele é acionado com uma tabela de objetos `Datatype.Vector2` que descrevem as posições relativas dos dedos envolvidos no gesto.

GuiObject.TouchTap

Um array de `Datatype.Vector2` que descreve as **posições** relativas dos dedos envolvidos no gesto.

Aciona quando o jogador realiza um gesto de toque no elemento da interface do usuário.

Este exemplo de código demonstra um uso mais envolvente do TweenPosition ao
detectar quando a animação é concluída/cancelada definindo uma função de callback. Ele
também imprime se a animação irá tocar.


Move suavemente uma GUI para uma nova posição `Datatype.UDim2` no tempo especificado usando a `Enum.EasingDirection` e `Enum.EasingStyle` especificadas.

Esta função retornará se o tween irá tocar. Ele não tocará se outro tween estiver agindo sobre o `Class.GuiObject` e o parâmetro de substituição for `false`.

Veja também `Class.GuiObject:TweenSize()` e `Class.GuiObject:TweenSizeAndPosition()`.

GuiObject:TweenPosition

endPosition

easingDirection

A direção na qual a GUI deve ser suavizada para a _endPosition_.

easingStyle

O estilo no qual a GUI deve ser suavizada para a _endPosition_.

time

Quanto tempo, em segundos, o tween deve levar para completar.

override

Se o tween irá substituir um tween em andamento.

callback

Uma função de callback a ser executada quando o tween for concluído.

Move suavemente uma GUI para um novo `Datatype.UDim2`.

Este exemplo de código demonstra o uso da função `Class.GuiObject:TweenSize()`
para iniciar uma animação na propriedade `Class.GuiObject.Size`
do pai para `UDim2.new(0.5, 0, 0.5, 0)`, que é metade do tamanho do `GuiObject`
no eixo X e Y.

Além disso, demonstra como o parâmetro de callback pode ser usado para detectar
quando a animação para (se foi cancelada por outra animação ou concluída).


Redimensiona suavemente um `Class.GuiObject` para um novo `Datatype.UDim2` no tempo especificado usando a `Enum.EasingDirection` e `Enum.EasingStyle` especificadas.

Esta função retornará se o tween irá tocar. Normalmente, isso sempre retornará `true`, mas retornará `false` se outro tween estiver ativo e a substituição estiver definida como `false`.

Veja também `Class.GuiObject:TweenSize()` e `Class.GuiObject:TweenSizeAndPosition()`.

GuiObject:TweenSize

endSize

A direção na qual a GUI deve ser suavizada para o _endSize_.

O estilo no qual a GUI deve ser suavizada para o _endSize_.

Redimensiona suavemente um `Class.GuiObject` para um novo `Datatype.UDim2`.

O exemplo abaixo animaria um `Class.Frame` para o canto superior esquerdo do tamanho do pai
 e redimensioná-lo para 0.


Redimensiona e move suavemente uma GUI para um novo tamanho e posição `Datatype.UDim2` no tempo especificado usando a `Enum.EasingDirection` e `Enum.EasingStyle` especificadas.

Esta função retornará se o tween irá tocar. Normalmente, isso sempre retornará `true`, mas retornará `false` se outro tween estiver ativo e a substituição estiver definida como `false`.

Veja também `Class.GuiObject:TweenSize()` e `Class.GuiObject:TweenSizeAndPosition()`.

GuiObject:TweenSizeAndPosition

A direção na qual a GUI deve ser suavizada para o _endSize_ e _endPosition_.

O estilo no qual a GUI deve ser suavizada para o _endSize_ e _endPosition_.

Move suavemente uma GUI para um novo tamanho e posição.

GuiObject

Este exemplo de código demonstra o uso da propriedade Ativo como um debounce
para o evento Ativado.

Esta propriedade determina se o `Class.GuiObject` irá absorver entrada para o espaço 3D, como modelos subjacentes com uma classe `Class.ClickDetector`, como `Class.DragDetector`.

Para objetos `Class.GuiButton` (`Class.ImageButton` e `Class.TextButton`), esta propriedade determina se `Class.GuiButton.Activated|Activated` é acionado (`Class.GuiButton.AutoButtonColor|AutoButtonColor` ainda funcionará para eles também). Os eventos `Class.GuiObject.InputBegan|InputBegan`, `Class.GuiObject.InputChanged|InputChanged` e `Class.GuiObject.InputEnded|InputEnded` funcionam normalmente, independentemente do valor desta propriedade.

GuiObject.Active

Determina se este elemento de UI absorve entrada.

Este exemplo de código move um elemento de UI para diferentes lados do elemento pai.
Começa no canto superior esquerdo e termina no canto inferior direito. Cole em um
LocalScript em um Frame, dentro de um ScreenGui.


Esta propriedade determina o ponto de origem de um `Class.GuiObject`, em relação ao seu tamanho absoluto. O ponto de origem determina de onde o elemento é posicionado (através de `Class.GuiObject.Position`) e de onde o `Class.GuiObject.Size` renderizado se expande.

Veja [aqui](/ui/position-and-size#anchorpoint) para diagramas ilustrados e detalhes.

GuiObject.AnchorPoint

Determina o ponto de origem de um `Class.GuiObject`, em relação ao seu tamanho absoluto.

O seguinte script cria um quadro pai com tamanho automático com
a `UIListLayout`, em seguida, insere vários objetos `TextLabel`
com tamanho automático. Note como o `UIListLayout` pai redimensiona automaticamente para caber seu
conteúdo filho e os rótulos redimensionam automaticamente para caber seu conteúdo de texto.
Este script pode ser parentado a um `ScreenGui`.


Esta propriedade é usada para dimensionar automaticamente objetos de UI pai com base no tamanho de seus descendentes. Você pode usar esta propriedade para adicionar dinamicamente texto e outros conteúdos a um objeto de UI em tempo de edição ou execução, e o tamanho se ajustará para caber nesse conteúdo.

Quando `Class.GuiObject.AutomaticSize|AutomaticSize` é definido para um valor `Enum.AutomaticSize` diferente de `Enum.AutomaticSize|None`, este objeto de UI pode redimensionar dependendo do seu conteúdo filho.

Para mais informações sobre como usar esta propriedade e como ela funciona, veja [aqui](/ui/size-modifiers#automatic-sizing).

GuiObject.AutomaticSize

Determina se o redimensionamento ocorre com base no conteúdo filho.

Determina a cor do fundo do `Class.GuiObject`.

GuiObject.BackgroundColor

Este exemplo de código faz com que uma Moldura pai percorra todas as cores do
arco-íris usando Color3.fromHSV.


Esta propriedade determina a cor de fundo de um `Class.GuiObject` (a cor de preenchimento). Se seu elemento contém texto, como um `Class.TextBox`, `Class.TextButton` ou `Class.TextLabel`, certifique-se de que a cor do seu fundo contrasta com a cor do texto.

Outra propriedade que determina as propriedades visuais do fundo é `Class.GuiObject.BackgroundTransparency`; se isso for definido como `1`, nem o fundo nem a borda serão renderizados.

Veja também `Class.GuiObject.BorderColor3|BorderColor3`.

GuiObject.BackgroundColor3

Determina a cor de fundo do `Class.GuiObject`.

Esta propriedade determina a transparência do fundo e da borda do `Class.GuiObject`. No entanto, não determina a transparência do texto se a GUI for um `Class.TextBox`, `Class.TextButton` ou `Class.TextLabel`; a transparência do texto é determinada por `Class.TextBox.TextTransparency`, `Class.TextButton.TextTransparency` e `Class.TextLabel.TextTransparency`, respectivamente.

Se esta propriedade for definida como `1`, nem o fundo nem a borda serão renderizados e o fundo da GUI será completamente transparente.

GuiObject.BackgroundTransparency

Determina a transparência do fundo e da borda do `Class.GuiObject`.

Determina a cor da borda do `Class.GuiObject`.

GuiObject.BorderColor

Este exemplo de código faz com que a borda de um GuiObject pai destaque quando o
usuário passa o mouse sobre o elemento.


Determina a cor da borda retangular do `Class.GuiObject` (também conhecida como a cor do traço). Isso é separado da `Class.GuiObject.BackgroundColor3`. Você não poderá ver a borda do objeto se a propriedade `Class.GuiObject.BorderSizePixel` estiver definida como `0`.

Observe que o componente `Class.UIStroke` permite efeitos de borda mais avançados.

GuiObject.BorderColor3

Esta propriedade determina de que maneira a borda do `Class.GuiObject` é disposta em relação às suas dimensões usando o enum de mesmo nome, `Enum.BorderMode`.

Observe que `Class.UIStroke` pode substituir esta propriedade e permitir efeitos de borda mais avançados.

GuiObject.BorderMode

Determina de que maneira a borda do `Class.GuiObject` é disposta em relação às suas dimensões.

Esta propriedade determina quão larga a borda do `Class.GuiObject` é renderizada, em pixels. Definir isso como 0 desabilita completamente a borda.

Observe que `Class.UIStroke` pode substituir esta propriedade e permitir efeitos de borda mais avançados.

GuiObject.BorderSizePixel

Determina a largura em pixels da borda do `Class.GuiObject`.

Esta propriedade determina se o `Class.GuiObject` irá recortar (tornar invisível) qualquer parte de elementos GUI descendentes que, de outra forma, seriam renderizados fora dos limites do retângulo.

#### Comportamento de Rotação

Quando `Class.StarterGui.ClipsDescendantsSupportsRotation` está habilitado, o recorte funciona corretamente para formas rotacionadas. No entanto, o recorte **por** formas rotacionadas (quando o pai do recorte em si está rotacionado) ou por cantos arredondados (`Class.UICorner`) não é suportado.

Quando `Class.StarterGui.ClipsDescendantsSupportsRotation` **não** está habilitado e este `Class.GuiObject` ou qualquer ancestral `Class.GuiObject` tem uma `Class.GuiObject.Rotation|Rotation` **diferente de zero**, esta propriedade é **ignorada** e os elementos GUI descendentes serão renderizados independentemente do valor desta propriedade.

GuiObject.ClipsDescendants

Determina se os descendentes `Class.GuiObject|GuiObjects` fora dos limites de um elemento GUI pai devem ser renderizados.

Isto indica se um `Class.GuiObject` (e seus descendentes) pode ser arrastado pela tela.

GuiObject.Draggable

Determina se um `Class.GuiObject` (e seus descendentes) pode ser arrastado pela tela.

Quando o dedo do jogador está sendo tocado e mantido no `Class.GuiObject`, o `Class.GuiObject.GuiState|GuiState` do `Class.GuiObject` será definido como `Enum.GuiState.Press|Press`. Da mesma forma, quando o dedo do jogador é liberado do `Class.GuiObject`, o `Class.GuiObject.GuiState|GuiState` do `Class.GuiObject` será definido como `Enum.GuiState.Idle|Idle`, e quando `Class.GuiObject.Interactable|Interactable` é desativado no `Class.GuiObject`, o `Class.GuiState` do `Class.GuiObject` será definido como `Enum.GuiState.NonInteractable|NonInteractable`.

GuiObject.GuiState

Determina se o mouse do jogador está sendo pressionado ativamente no `Class.GuiObject` ou não.

Controla se, e em que grau, o `Class.GuiObject` absorve a entrada que ocorre sobre ele, usando `Enum.InputSink`. Absorver entrada impede que ela passe para objetos atrás do elemento, incluindo objetos 3D no mundo, como aqueles com um `Class.ClickDetector` ou `Class.DragDetector`. O padrão é `Enum.InputSink.None`, exceto em objetos `Class.GuiButton` (`Class.ImageButton` e `Class.TextButton`), onde o padrão é `Enum.InputSink.Activate`.

- `Enum.InputSink.None` — o objeto não absorve entrada por conta própria.
- `Enum.InputSink.Activate` — o objeto absorve a entrada de pressionar/liberar o botão do mouse e toque usado para ativá-lo, mas permite que outras entradas (como movimento do mouse) passem.
- `Enum.InputSink.All` — o objeto absorve toda a entrada que ocorre sobre ele.

Esta propriedade é um sucessor mais granular da propriedade booleana `Class.GuiObject.Active|Active`, que só pode absorver toda a entrada ou nenhuma. Os eventos `Class.GuiObject.InputBegan|InputBegan`, `Class.GuiObject.InputChanged|InputChanged` e `Class.GuiObject.InputEnded|InputEnded` disparam independentemente do valor desta propriedade.

GuiObject.InputSink

Controla se, e como, o `Class.GuiObject` absorve a entrada que ocorre sobre ele.

Determina se o `Class.GuiButton` pode ser interagido ou não, ou se o `Enum.GuiState|GuiState` do `Class.GuiObject` está mudando ou não.

Em um `Class.GuiButton`:

- Quando a configuração `Class.GuiObject.Interactable|Interactable` no `Class.GuiButton` é definida como `false`, o `Class.GuiButton` não poderá mais ser pressionado ou clicado, e o `Class.GuiObject.GuiState|GuiState` será constantemente definido como `Enum.GuiState.NonInteractable|NonInteractable`.
- Quando a configuração `Class.GuiObject.Interactable|Interactable` no `Class.GuiButton` é definida como `true`, o `Class.GuiButton` se comportará normalmente novamente e o `Class.GuiObject.GuiState|GuiState` se comportará normalmente.

Em um `Class.GuiObject`:

- Quando a configuração `Class.GuiObject.Interactable|Interactable` no `Class.GuiButton` é definida como `false`, o `Class.GuiObject.GuiState|GuiState` será constantemente definido como `Enum.GuiState.NonInteractable|NonInteractable`.
- Quando a configuração `Class.GuiObject.Interactable|Interactable` no `Class.GuiButton` é definida como `true`, o `Class.GuiObject.GuiState|GuiState` se comportará normalmente novamente.

GuiObject.Interactable

Determina se o `Class.GuiButton` pode ser interagido ou não, ou se o `Enum.GuiState|GuiState` do `Class.GuiObject` está mudando ou não.

Esta propriedade controla a ordem de classificação do `Class.GuiObject` ao usar um `Class.UIGridStyleLayout` (como `Class.UIListLayout` ou `Class.UIPageLayout`) com `Class.UIGridStyleLayout.SortOrder|SortOrder` definido como `Enum.SortOrder.LayoutOrder`. Não tem funcionalidade se o objeto não tiver uma estrutura de layout de UI irmã.

`Class.GuiObject|GuiObjects` são classificados em ordem crescente, onde valores mais baixos têm prioridade sobre valores mais altos. Objetos com valores iguais voltam à ordem em que foram adicionados.

Se você não tiver certeza se precisará adicionar um elemento entre dois elementos existentes no futuro, é uma boa prática usar múltiplos de `100` (`0`, `100`, `200`, etc.). Isso garante uma grande lacuna de valores de ordem de layout que você pode usar para elementos ordenados entre outros elementos.

Veja também `Class.GuiObject.ZIndex|ZIndex`, que determina a ordem de **renderização** do objeto em vez da ordem de classificação.

GuiObject.LayoutOrder

Controla a ordem de classificação do `Class.GuiObject` quando usado com um `Class.UIGridStyleLayout`.

Este exemplo demonstra como habilitar a navegação por Gamepad através de uma grade de
`GuiObject|GUI` elementos sem precisar conectar manualmente os
`Class.GuiObject.NextSelectionUp`, `Class.GuiObject.NextSelectionDown`, e
`GuiObject|NextSelectionRight`, e `Class.GuiObject.NextSelectionLeft`
propriedades para cada elemento na grade.

Note que este exemplo de código assume que seu `UIGridLayout` está ordenado por
`Class.UIGridLayout.SortOrder|name`, onde os elementos são nomeados em ordem
numérica sucessiva.

O código depende disso para definir as propriedades NextSelection para todos
`GuiObjects` no mesmo nível que o UIGridLayout. No nosso exemplo, o
UIGridLayoutObject e os elementos GUI dentro da grade são todos filhos de um
`Frame` chamado _"Container"_. O código
`Class.Instance:GetChildren()|obtém os filhos` de _"Container"_ e itera
por cada filho. Filhos que não são GuiObjects são ignorados. Para cada elemento GUI,
o código tenta atribuir as propriedades NextSelection usando a
seguinte lógica:

1. Começando com 1, o nome de todos os elementos GUI corresponde à sua posição na
   grade
2. Esquerda: O item à esquerda sempre terá o número 1 a menos que o elemento atual
3. Direita: O item à direita sempre terá o número 1 a mais que o elemento atual
4. Cima: O item acima (cima) sempre será o número de GUIs em uma linha 1 a menos que
   o elemento atual
5. Abaixo: O item abaixo (abaixo) sempre será o número de GUIs em uma linha a mais
   que o elemento atual Esta lógica também permite que os elementos GUI no
   início e no final das linhas (excluindo o primeiro e o último elemento) se
   conectem à próxima e à linha anterior. Se um elemento não existir à
   esquerda, direita, acima ou abaixo, o NextSelection permanecerá nil e mover o
   seletor do Gamepad na direção não mudará o GUI selecionado.

Este exemplo também contém código para testar a grade usando as teclas de seta (Cima,
Abaixo, Esquerda, Direita) do seu teclado em vez de um gamepad, caso você
não tenha um gamepad para testar. Esta parte do código inicialmente seleciona o
elemento chamado _"1"_ atribuindo-o à propriedade `Class.GuiService.SelectedObject`.


Esta propriedade define o `Class.GuiObject` selecionado quando o usuário move o seletor do [gamepad](/input/gamepad) para baixo. Se esta propriedade estiver vazia, mover o gamepad para baixo não mudará a GUI selecionada.

Mover o seletor do gamepad para baixo define o `Class.GuiService.SelectedObject` para este objeto, a menos que a GUI não seja `Class.GuiObject.Selectable|Selectable`. Observe que esta propriedade pode ser definida para um elemento GUI mesmo que não seja `Class.GuiObject.Selectable|Selectable`, então você deve garantir que o valor da propriedade selecionável de uma GUI corresponda ao seu comportamento esperado.

Veja também `Class.GuiObject.NextSelectionUp|NextSelectionUp`, `Class.GuiObject.NextSelectionLeft|NextSelectionLeft` e `Class.GuiObject.NextSelectionRight|NextSelectionRight`.

GuiObject.NextSelectionDown

Define o `Class.GuiObject` que será selecionado quando o seletor do gamepad for movido para baixo.

Esta propriedade define o `Class.GuiObject` selecionado quando o usuário move o seletor do [gamepad](/input/gamepad) para a esquerda. Se esta propriedade estiver vazia, mover o gamepad para a esquerda não mudará a GUI selecionada.

Mover o seletor do gamepad para a esquerda define o `Class.GuiService.SelectedObject` para este objeto, a menos que a GUI não seja `Class.GuiObject.Selectable|Selectable`. Observe que esta propriedade pode ser definida para um elemento GUI mesmo que não seja `Class.GuiObject.Selectable|Selectable`, então você deve garantir que o valor da propriedade selecionável de uma GUI corresponda ao seu comportamento esperado.

Veja também `Class.GuiObject.NextSelectionUp|NextSelectionUp`, `Class.GuiObject.NextSelectionDown|NextSelectionDown` e `Class.GuiObject.NextSelectionRight|NextSelectionRight`.

GuiObject.NextSelectionLeft

Define o `Class.GuiObject` que será selecionado quando o seletor do gamepad for movido para a esquerda.

Esta propriedade define o `Class.GuiObject` selecionado quando o usuário move o seletor do [gamepad](/input/gamepad) para a direita. Se esta propriedade estiver vazia, mover o gamepad para a direita não mudará a GUI selecionada.

Mover o seletor do gamepad para a direita define o `Class.GuiService.SelectedObject` para este objeto, a menos que a GUI não seja `Class.GuiObject.Selectable|Selectable`. Observe que esta propriedade pode ser definida para um elemento GUI mesmo que não seja `Class.GuiObject.Selectable|Selectable`, então você deve garantir que o valor da propriedade selecionável de uma GUI corresponda ao seu comportamento esperado.

Veja também `Class.GuiObject.NextSelectionUp|NextSelectionUp`, `Class.GuiObject.NextSelectionDown|NextSelectionDown` e `Class.GuiObject.NextSelectionLeft|NextSelectionLeft`.

GuiObject.NextSelectionRight

Define o `Class.GuiObject` que será selecionado quando o seletor do gamepad for movido para a direita.

Esta propriedade define o `Class.GuiObject` selecionado quando o usuário move o seletor do [gamepad](/input/gamepad) para cima. Se esta propriedade estiver vazia, mover o gamepad para cima não mudará a GUI selecionada.

Mover o seletor do gamepad para cima define o `Class.GuiService.SelectedObject` para este objeto, a menos que a GUI não seja `Class.GuiObject.Selectable|Selectable`. Observe que esta propriedade pode ser definida para um elemento GUI mesmo que não seja `Class.GuiObject.Selectable|Selectable`, então você deve garantir que o valor da propriedade selecionável de uma GUI corresponda ao seu comportamento esperado.

Veja também `Class.GuiObject.NextSelectionDown|NextSelectionDown`, `Class.GuiObject.NextSelectionLeft|NextSelectionLeft` e `Class.GuiObject.NextSelectionRight|NextSelectionRight`.

GuiObject.NextSelectionUp

Define o `Class.GuiObject` que será selecionado quando o seletor do gamepad for movido para cima.

Uma classe abstrata para todos os objetos de interface de usuário 2D.

/reference/engine/classes/TextChannelWindow.yaml

Resumo