`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 do canal a janela exibe. A janela se registra com
`Class.TextChatService` quando adicionada ao modelo de dados.

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

`Class.GuiObject` é uma classe abstrata (muito parecida com `Class.BasePart`) para um objeto de interface do 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` têm 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 a forma 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 a forma 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 é disparado, 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 é disparado, 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 está dentro de um elemento `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, ele disparará repetidamente enquanto 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 o delta desde a posição anterior do mouse, se estiver sendo rastreado 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:

```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)
```
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 em que 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 dispara quando o jogador usa dois dedos para fazer um gesto de pinça ou puxar no elemento da UI usando um dispositivo com tela sensível ao toque. Um **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 dispara em conjunto com `Class.GuiObject.TouchPan`. Este evento é útil para permitir que o jogador manipule a escala (tamanho) dos elementos da UI na tela e é mais frequentemente usado para recursos de zoom.

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 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 dispara quando o jogador usa dois dedos para fazer um gesto de pinça ou puxar
no elemento da UI usando um dispositivo com tela sensível ao toque. A rotação ocorre
quando o ângulo da linha entre os dois dedos muda. Este evento dispara
em conjunto com `Class.GuiObject.TouchPan`. Este evento é útil para
permitir que o jogador manipule a rotação dos elementos da UI na
tela.

Este evento dispara com uma tabela de `Datatype.Vector2` que descreve as
posições relativas na tela 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 um dedo
durante o gesto, e finalmente com `Enum.UserInputState.End`.

GuiObject.TouchRotate

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

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.

Dispara quando o jogador realiza um gesto de rotação usando dois dedos no
elemento da UI.

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 dispara quando o jogador realiza um gesto de deslizar no elemento da UI usando um dispositivo com tela sensível ao toque. Ele dispara 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 UIs 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).

Dispara quando o jogador realiza um gesto de deslizar no elemento da UI.

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 dispara quando o jogador realiza um gesto de toque no elemento da UI 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 dispararia
`Class.GuiObject.TouchLongPress`, e mover durante o toque dispararia
`Class.GuiObject.TouchPan` e/ou `Class.GuiObject.TouchSwipe`). Ele dispara
com uma tabela de `Datatype.Vector2` objetos 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.

Dispara quando o jogador realiza um gesto de toque no elemento da UI.

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 suavizar a GUI para a _endPosition_.

easingStyle

O estilo no qual suavizar a GUI 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 suavizar a GUI para o _endSize_.

O estilo no qual suavizar a GUI 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 suavizar a GUI para o _endSize_ e _endPosition_.

O estilo no qual suavizar a GUI 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, consulte [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 a 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`),
donde 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` são acionados independentemente do valor desta
propriedade.


GuiObject.InputSink

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


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ão.

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

Esta propriedade determina a posição em pixels e escala do `Class.GuiObject` usando um `Datatype.UDim2`. A posição é centrada em torno do `Class.GuiObject.AnchorPoint` do objeto.

A posição em escala é relativa ao tamanho do elemento GUI pai, se houver.

As porções em pixels do valor `Datatype.UDim2` são as mesmas, independentemente do tamanho da GUI pai. Os valores representam a posição do objeto em pixels. A posição real em pixels de um objeto pode ser lida da propriedade `Class.GuiBase2d.AbsolutePosition`.

GuiObject.Position

Determina a posição em pixels e escala do `Class.GuiObject`.

Esta propriedade determina o número de graus pelos quais o `Class.GuiObject` é rotacionado. A rotação é relativa ao **centro** do objeto, **não** ao `Class.GuiObject.AnchorPoint|AnchorPoint`, o que significa que você não pode mudar o ponto de rotação. Além disso, esta propriedade não é compatível com `Class.GuiObject.ClipsDescendants|ClipsDescendants`.

GuiObject.Rotation

Determina o número de graus pelos quais o `Class.GuiObject` é rotacionado.

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

/reference/engine/classes/TextChannelWindow.yaml