`CanvasGroup` renderiza descendentes como um grupo com cor e transparência
aplicadas ao resultado da renderização. Modificadores visuais de `Class.UIComponent`, como
`Class.UICorner` e `Class.UIGradient` sob um `CanvasGroup` também se aplicarão
ao grupo inteiro. Note que `CanvasGroup` sempre tem
`Class.GuiObject.ClipsDescendants|ClipsDescendants` definido como `true` e todos
os descendentes serão renderizados dentro da área de visualização do grupo.

#### Observações Importantes

- Os descendentes do `CanvasGroup` serão renderizados como uma textura achatada apenas
  quando o ancestral `Class.LayerCollector` tiver seu
  `Class.LayerCollector.ZIndexBehavior|ZIndexBehavior` definido como
  `Enum.ZIndexBehavior.Sibling`.
- `CanvasGroup` consome memória de textura extra. A qualidade da textura e
  o uso total de memória é limitado pelo `Enum.QualityLevel` do cliente. Quando
  ultrapassar o limite de memória, `CanvasGroup` será renderizado como uma textura em branco.
- É recomendável usar `CanvasGroup` com tamanhos estáticos, caso contrário, uma nova
  textura precisaria ser criada para acomodar novos tamanhos.


CanvasGroup

Cor de tonalidade que se aplica a todos os descendentes.

CanvasGroup.GroupColor3

Transparência que se aplica a todos os descendentes.

CanvasGroup.GroupTransparency

Mistura os descendentes como um grupo com cor/transparência.

`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 gráfico de interface do usuário (GUI), como `Class.GuiObject.Size|Size`
e `Class.GuiObject.Position|Position`. Também possui algumas propriedades úteis apenas para 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 você pode estilizar além de suas
propriedades fundamentais através dos
[modificadores de aparência](/ui/appearance-modifiers).

Embora seja possível detectar eventos de botões 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/impressões.

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

Este evento dispara 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á
a posição X e Y onde o jogador parou de arrastar o GUI. Por exemplo, se o
jogador parasse de arrastar o objeto em 189, 180, o abaixo imprimiria "O
jogador parou de arrastar o GuiObject em (189, 180)"

Este evento dispara quando um jogador para de arrastar o objeto.

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

GuiObject.DragStopped

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

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

Disparado quando um jogador para de arrastar o objeto.

O exemplo a seguir demonstra um dos muitos exemplos de uso de tratamento de entrada do usuário
a partir do 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 dispara quando um usuário começa a interagir com o `Class.GuiObject`
via um dispositivo de Interface Humano-Computador (Botão do mouse pressionado, início do toque,
botão do teclado pressionado, etc).

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

Este evento será sempre 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`,
o `Enum.UserInputState|estado da entrada`, e
as `Class.InputObject.Position|coordenadas na tela da entrada`.

Disparado quando um usuário começa a interagir via um dispositivo de Interface Humano-Computador
(Botão do mouse pressionado, início do toque, 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
a partir de InputChanged, dependendo de seu tipo.

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

Este evento dispara quando um usuário muda como está interagindo via um
 dispositivo de Interface Humano-Computador (Botão do mouse pressionado, início do toque, botão do teclado
 pressionado, etc).

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

Este evento será sempre 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, início do toque, botão do teclado pressionado, etc).

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

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

O evento InputEnded dispara quando um usuário para de interagir via um
dispositivo de Interface Humano-Computador (Botão do mouse pressionado, início do toque, botão
do teclado pressionado, etc).

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

Este evento será sempre 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, início do toque, 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
`Class.GuiObject` elemento.

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

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

Se você deseja 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 em **X** em pixels, em relação ao canto
superior esquerdo da tela.

A coordenada de tela do mouse em **Y** em pixels, em relação 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 seu mouse para fora de um
`Class.GuiObject` elemento.

Por favor, não confie nos argumentos `x` e `y` passados por este evento como uma
maneira infalível de determinar onde o mouse do usuário está quando sai de um
GUI. Essas coordenadas podem variar mesmo quando o mouse sai da GUI através da
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, e não no exato momento em que o mouse sai da GUI.

Este evento dispara mesmo quando o elemento GUI renderiza 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
`Class.GuiObject` elemento. É semelhante a `Class.Mouse.Move`, que
dispara independentemente de o mouse do usuário estar sobre um elemento GUI.

Note que este evento é acionado quando a posição do mouse é atualizada, portanto, ele
será disparado repetidamente enquanto está sendo movido.

Os argumentos `x` e `y` indicam as coordenadas de tela atualizadas do
mouse do usuário em pixels. Eles 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
de 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 coincidir
perfeitamente com as 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 ele 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 `Class.GuiObject` elemento. É 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 `Class.GuiObject` elemento. É 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 as 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 ser um filho de _gui_.

Este evento dispara 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,
você 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
aquela que ganha a seleção. Para determinar qual GUI ganhou a seleção, verifique
 o valor dessa 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.

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

Este evento dispara 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,
você 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
a GUI que ganha o foco de seleção. Para determinar qual GUI ganhou a seleção,
ou se nenhuma GUI está selecionada, verifique o valor dessa 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 UI, como um `Frame`, segurando o elemento UI por um breve
momento. Então, o jogador move o dedo e solta. Durante o gesto
o Frame é colorido de azul com um contorno branco.

Este evento é acionado após um breve momento em que o jogador mantém o dedo
no elemento da interface do usuário usando um dispositivo com toque. Ele é acionado com uma tabela de
`Datatype.Vector2` que descreve as posições relativas na tela dos
dedos envolvidos na ação. Além disso, ele é acionado várias vezes:
`Enum.UserInputState.Begin` após um breve atraso,
`Enum.UserInputState.Change` se o jogador mover o dedo durante a
gerência, e finalmente `Enum.UserInputState.End`. O atraso é dependente da
tela; no Studio é um pouco mais longo que um segundo.

GuiObject.TouchLongPress

touchPositions

Um array de `Datatype.Vector2` que descrevem as **posições relativas**
do 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 de 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 quadro interno movendo seu dedo no
quadro externo.

Este evento é acionado quando o jogador move o dedo no elemento da interface do usuário
usando um dispositivo com toque. Ele é acionado pouco antes que
`Class.GuiObject.TouchSwipe` o faria, e não é acionado com
`Class.GuiObject.TouchTap`. Este evento é útil para permitir que o jogador
manipule a posiçã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 na ação. Além disso, ele é
acionado várias vezes: `Enum.UserInputState.Begin` após um
breve atraso, `Enum.UserInputState.Change` quando o jogador move seu
com dedo durante a ação, 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 se deslocou a partir do seu ponto de partida.

velocity

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

Dispara quando o jogador move o dedo sobre o elemento de 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çamento ou puxar
no elemento da interface do usuário usando um dispositivo com toque. Um **pinçamento**
ocorre quando dois ou mais dedos se movem mais próximos um do outro, e um **puxar**
ocorre 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
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 na ação. 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 a ação, 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çar.

scale

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

Um float que indica quão rápida está acontecendo a gestura de pinçar.

Dispara quando o jogador realiza um gesto de pinçar ou puxar usando dois dedos
no elemento de 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 gire
o frame interno realizando um gesto de `Class.GuiObject.TouchRotate` no
frame externo.


Este evento é acionado quando o jogador usa dois dedos para fazer um gesto de pinçamento ou puxar
no elemento da interface do usuário usando um dispositivo com 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
na tela.

Este evento é acionado com uma tabela de `Datatype.Vector2` que descreve as
posições relativas na tela dos dedos envolvidos na ação. 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 a ação, e finalmente com `Enum.UserInputState.End`.

GuiObject.TouchRotate

Uma matriz Luau de objetos `Datatype.Vector2`, cada uma 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`) pule quando um
gesto de deslizar for realizado em um dispositivo com toque (ou no emulador do Studio).
Deslizamentos horizontais mudarão o tom de
`Class.GuiObject.BackgroundColor3`, enquanto deslizamentos verticais mudarão a
saturação.

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

GuiObject.TouchSwipe

swipeDirection

Um `Enum.SwipeDirection` indicando a direção do gesto de deslizamento
(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 deslizamento 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 é acionado quando o jogador realiza um gesto de toque no elemento da interface
usando um dispositivo com toque. Um toque é um toque único rápido sem qualquer
movimento envolvido (um toque 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 `Datatype.Vector2` objetos que descrevem as posições relativas
dos dedos envolvidos na ação.

GuiObject.TouchTap

Uma matriz 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 elaborado de TweenPosition ao
detectar quando a animação é concluída/cancelada definindo uma função de callback.
Ele também imprime se a animação será reproduzida.

Move suavemente uma GUI para uma nova posição `Datatype.UDim2` no tempo especificado
usando a direção de easing e o estilo de easing especificados.

Esta função irá retornar se o tween será reproduzido. Ele não irá reproduzir se
outro tween estiver atuando no `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 até a _endPosition_.

easingStyle

O estilo no qual suavizar a GUI até a _endPosition_.

time

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

override

Se o tween irá substituir um tween em progresso.

callback

Uma função de callback a ser executada quando o tween completar.

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

Este exemplo de código demonstra o uso da função `Class.GuiObject:TweenSize()`.
Ele inicia 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`
do pai em ambos os eixos.

Além disso, demonstra como o parâmetro de retorno 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 direção de easing e o estilo de easing especificados.

Esta função irá retornar se o tween será reproduzido. Normalmente isso sempre
deverá retornar `true`, mas irá retornar `false` se outro tween estiver
ativo e o override estiver definido como `false`.

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

GuiObject:TweenSize

endSize

A direção na qual suavizar a GUI até o _endSize_.

O estilo no qual suavizar a GUI até 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 pai's
tamanho e redimensioná-lo para 0.

Redimensiona e move suavemente uma GUI para um novo tamanho `Datatype.UDim2` e
 posição no tempo especificado usando a direção de easing e o estilo de easing especificados.

Esta função irá retornar se o tween será reproduzido. Normalmente isso sempre
deverá retornar `true`, mas irá retornar `false` se outro tween estiver
ativo e o override estiver definido como `false`.

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

GuiObject:TweenSizeAndPosition

A direção na qual suavizar a GUI até o _endSize_ e
_endPosition_.

O estilo no qual suavizar a GUI até 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 entradas para
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
esses 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 entradas.

Este código de exemplo 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 a partir do qual o
renderizado `Class.GuiObject.Size` se expande.

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

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
um `UIListLayout`, e então insere vários objetos `TextLabel`
com tamanho automático. Observe 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 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 UI em tempo de edição ou execução, e o tamanho irá
ajustar-se para se adequar a esse conteúdo.

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

Para mais informações sobre como usar esta propriedade e como ela funciona, por favor
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 um Frame 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 estiver definido como `1`,
nenhum dos fundos ou da borda será renderizado.

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`.
Não determina, no entanto, 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 estiver 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
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` do objeto. 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`.

Note que `Class.UIStroke` pode sobrescrever essa 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` renderiza,
em pixels. Definir isso como 0 desabilita totalmente a borda.

Note que `Class.UIStroke` pode sobrescrever essa 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,
renderizariam fora dos limites do retângulo.

Note que `Class.GuiObject.Rotation|Rotation` não é suportado por esta
propriedade. Se esta ou qualquer GUI ancestral tiver uma **não zero**
`Class.GuiObject.Rotation|Rotation`, esta propriedade será **ignorada** e os
elementos GUI descendentes serão renderizados independentemente do valor
 desta propriedade.

GuiObject.ClipsDescendants

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

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

GuiObject.Draggable

Determina se um `Class.GuiObject` (e seus descendentes) podem ser
arrastados pela tela.

Quando o dedo do jogador está sendo tocado e segurado 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 está sendo solto 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á
configurado para `Enum.GuiState.NonInteractable|NonInteractable`.

GuiObject.GuiState

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

GuiObject.InputSink

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` está 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` está 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` está 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` está 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
retornam à ordem em que foram adicionados.

Se você não tiver certeza se precisará adicionar um elemento entre dois
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**
dos objetos 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 pelo 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 da grade.

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

O código se baseia nisso 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 faz um loop
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. Baixo: O item abaixo (baixo) sempre será o número de GUIs em uma linha a mais
   que o elemento atual. Essa 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 às próximas e anteriores linhas. 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 um código para testar a grade usando as teclas de seta (Cima,
Baixo, Esquerda, Direita) do seu teclado em vez de um gamepad, caso você
deseje testar sem um gamepad. 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`. Note que esta propriedade pode ser
definida para um elemento da 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`. Note que esta propriedade pode ser
definida para um elemento da 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`. Note que esta propriedade pode ser
definida para um elemento da 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`. Note que esta propriedade pode ser
definida para um elemento da 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 pixel e escalar do `Class.GuiObject`
usando um `Datatype.UDim2`. A posição é centralizada em torno do `Class.GuiObject.AnchorPoint`.

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

As partes em pixels do valor de `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 pixel real de um objeto pode ser lida da propriedade
`Class.GuiBase2d.AbsolutePosition`.


GuiObject.Position

Determina a posição pixel e escalar 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/CanvasGroup.yaml