Um `Class.VideoDisplay` é um objeto GUI que exibe conteúdo de vídeo de um
`Class.VideoPlayer` conectado via um `Class.Wire`. Funciona de forma semelhante a um
`Class.ImageLabel`, mas é projetado para reprodução de vídeo.

Dispara após um `Class.Wire` se conectar ou desconectar, e que
`Class.Wire` agora está ou estava anteriormente conectado a um pino no
`Class.VideoDisplay` e a alguma outra instância conectável.

VideoDisplay.WiringChanged

connected

Se a instância foi conectada ou desconectada.

O pino no `Class.VideoDisplay` que o `Class.Wire` direciona.

wire

O `Class.Wire` entre o `Class.VideoDisplay` e a outra
instância.

instance

A outra instância que está ou estava conectada através do `Class.Wire`.

Dispara quando outra instância é conectada ou desconectada do
`Class.VideoDisplay` via um `Class.Wire`.

Retorna um array de `Class.Wire|Wires` que estão conectados ao pino especificado. 
`Class.VideoDisplay` tem um pino "Input".

VideoDisplay:GetConnectedWires

Um pino de entrada ou saída nesta instância

Retorna um array de `Class.Wire|Wires` que estão conectados ao pino especificado.

Obtém a lista de pinos que `Class.Wire` pode usar em `Class.Wire.TargetName`
para se conectar a esta instância através da propriedade `Class.Wire.TargetInstance`.

Para `Class.VideoDisplay`, isso é apenas `Input`.

VideoDisplay:GetInputPins

Um array de strings representando nomes de pinos válidos.

Obtém a lista de pinos que `Class.Wire` pode usar em `Class.Wire.TargetName`
para se conectar a esta instância através da propriedade `Class.Wire.TargetInstance`.

Obtém a lista de pinos que `Class.Wire` pode usar em `Class.Wire.SourceName`
para se conectar a esta instância através da propriedade `Class.Wire.SourceInstance`.

Para `Class.VideoDisplay`, não há nenhum.

VideoDisplay:GetOutputPins

Obtém a lista de pinos que `Class.Wire` pode usar em `Class.Wire.SourceName`
para se conectar a esta instância através da propriedade `Class.Wire.SourceInstance`.

VideoDisplay

Determina como o vídeo aparece quando é redimensionado. Por padrão, o vídeo
suaviza a texturização quando exibido na tela maior ou menor do que
seu tamanho na memória de textura. Quando definido como
`Enum.ResamplerMode.Pixelated|Enum.ResamplerMode.Pixelated`, o vídeo
preserva as bordas nítidas dos pixels.

VideoDisplay.ResampleMode

Seleciona o modo de reamostragem de textura para o `Class.VideoDisplay`.

Determina como uma textura de vídeo é renderizada quando a proporção de aspecto do
elemento da UI difere da proporção de aspecto do vídeo fonte.

Por padrão, esta propriedade é `Enum.ScaleType.Stretch`, que simplesmente
estica/compacta as dimensões da textura de vídeo para que se encaixem exatamente no
espaço do elemento da UI.

VideoDisplay.ScaleType

Determina como um vídeo será redimensionado se exibido em um elemento da UI cujo
proporção de aspecto difere do vídeo fonte.

VideoDisplay.TileSize

Determina como um vídeo é colorido. Quando definido como branco, nenhuma coloração
ocorre. Esta propriedade é útil para reutilizar ativos de vídeo.

VideoDisplay.VideoColor3

Determina como um vídeo renderizado será colorido.

Permite a exibição parcial de um vídeo em conjunto com
`Class.VideoDisplay.VideoRectSize|VideoRectSize`. Esta propriedade determina
o deslocamento em pixels (a partir do canto superior esquerdo) da área de vídeo a
ser exibida.

VideoDisplay.VideoRectOffset

O deslocamento em pixels da subárea de um vídeo a ser exibido.

Permite a exibição parcial de um vídeo em conjunto com
`Class.VideoDisplay.VideoRectOffset|VideoRectOffset`. Esta propriedade
determina o tamanho em pixels da área de vídeo a ser exibida. Se qualquer
dimensão for definida como `0`, o vídeo inteiro é exibido em vez disso.

VideoDisplay.VideoRectSize

Determina o tamanho em pixels da subárea de um vídeo a ser exibido.

Determina o alfa da textura de vídeo renderizada de um elemento da UI. Um valor de
`0` é completamente opaco, e um valor de `1` é completamente transparente
(invisível).

VideoDisplay.VideoTransparency

Determina a transparência do vídeo renderizado.

Um objeto GUI que exibe conteúdo de vídeo de um `Class.VideoPlayer` conectado.

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

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

/reference/engine/classes/VideoDisplay.yaml