`Class.TextChannelWindow` es un `Class.GuiObject` que renderiza en-experiencia
mensajes de chat de texto de un `Class.TextChannel` vinculado. Colócalo bajo un
`Class.ScreenGui` u otro descendiente de `Class.LayerCollector` para mostrar el chat
en una ubicación y diseño personalizados.

Establece `Class.TextChannelWindow.Target|Target` a un `Class.TextChannel` para elegir
qué mensajes de canal muestra la ventana. La ventana se registra a sí misma con
`Class.TextChatService` cuando se añade al modelo de datos.

Las propiedades establecidas en `Class.ChatWindowConfiguration` no se aplican a esta ventana.

Hijos aceptados: `Class.UICorner`, `Class.UIAspectRatioConstraint`,
`Class.UISizeConstraint`, y scripts (`Class.LocalScript`, `Class.Script`,
`Class.ModuleScript`); otros tipos de hijos son rechazados.


TextChannelWindow

Una referencia al `Class.TextChannel` cuyos mensajes esta ventana renderiza.
Cuando se establece, la ventana muestra mensajes del canal especificado. Establecer
esta propiedad a `nil` desconecta la ventana de cualquier canal, por lo que
display no muestra mensajes.

El valor predeterminado es `nil` (sin canal vinculado).

TextChannelWindow.Target

Muestra el canal RBXGeneral en una ventana personalizada con una fuente no predeterminada. Pega
esto en un LocalScript.


Fuente utilizada para renderizar los mensajes de esta ventana y su barra de entrada. Se aplica solo
cuando `Class.TextChannelWindow.UseDefaultFont` es `false`.


TextChannelWindow.FontFace

Fuente utilizada para renderizar texto en esta ventana.


Cuando es `true` (predeterminado), la ventana utiliza la fuente predeterminada de la plataforma en vivo.
Cuando es `false`, la ventana utiliza `Class.TextChannelWindow.FontFace|FontFace`.


TextChannelWindow.UseDefaultFont

Si esta ventana utiliza la fuente predeterminada de la plataforma en vivo.


`Class.GuiObject` es una clase abstracta (muy similar a `Class.BasePart`) para un objeto de interfaz de usuario 2D. Define todas las propiedades relacionadas con la visualización de un objeto de interfaz gráfica (GUI) como `Class.GuiObject.Size|Size` y `Class.GuiObject.Position|Position`. También tiene algunas propiedades útiles de solo lectura como `Class.GuiObject.AbsolutePosition|AbsolutePosition`, `Class.GuiObject.AbsoluteSize|AbsoluteSize` y `Class.GuiObject.AbsoluteRotation|AbsoluteRotation`.

Para manipular el diseño de los objetos GUI de maneras especiales, puedes usar una estructura de diseño como [list/flex](/ui/list-flex-layouts) o [grid](/ui/grid-table-layouts), y puedes estilizar más allá de sus propiedades básicas a través de [appearance modifiers](/ui/appearance-modifiers).

Aunque es posible detectar eventos de botones del mouse en cualquier objeto GUI usando `Class.GuiObject.InputBegan|InputBegan` y `Class.GuiObject.InputEnded|InputEnded`, solo `Class.ImageButton` y `Class.TextButton` tienen eventos dedicados convenientes como `Class.TextButton.Activated|Activated` para detectar clics/presiones.

El siguiente ejemplo asume que está dentro de un GuiObject como un `TextButton`, y
que la propiedad `Class.GuiObject.Draggable` está configurada como verdadera. Imprimirá
el UDim2 de donde el jugador comenzó a arrastrar el objeto.

Este evento se activa cuando un jugador comienza a arrastrar el objeto.

Consulta también `Class.GuiObject.DragStopped`.

GuiObject.DragBegin

initialPosition

Un valor `Datatype.UDim2` de la posición del `Class.GuiObject` antes de que comenzara cualquier operación de arrastre.

Se activa cuando un jugador comienza a arrastrar el objeto.

El siguiente ejemplo asume que está dentro de un GuiObject como un `TextButton`, y
que la propiedad `Class.GuiObject.Draggable` está establecida en verdadero. Imprimirá
las coordenadas X e Y de dónde el jugador dejó de arrastrar la GUI. Por ejemplo, si el
jugador dejara de arrastrar el objeto en 189, 180, el siguiente mensaje imprimiría "El
jugador dejó de arrastrar el GuiObject en (189, 180)"

Este evento se activa cuando un jugador deja de arrastrar el objeto.

Consulta también `Class.GuiObject.DragBegin`.

GuiObject.DragStopped

La ubicación en píxeles de la **X** del mouse en la pantalla, relativa a la esquina superior izquierda de la pantalla.

La ubicación en píxeles de la **Y** del mouse en la pantalla, relativa a la esquina superior izquierda de la pantalla.

Se activa cuando un jugador deja de arrastrar el objeto.

El siguiente ejemplo demuestra uno de muchos ejemplos de uso de cómo manejar la entrada del usuario desde InputBegan dependiendo de su tipo.
Para que esto funcione como se espera, debe colocarse en un `LocalScript`
y ser hijo de _gui_.

Este evento se activa cuando un usuario comienza a interactuar con el `Class.GuiObject` a través de un dispositivo de interfaz humano-computadora (botón del mouse presionado, inicio de toque, botón del teclado presionado, etc).

El `Class.UserInputService` tiene un evento de nombre similar que no está restringido a un elemento de UI específico: `Class.UserInputService.InputBegan`.

Este evento siempre se activará independientemente del estado del juego.

Consulta también `Class.GuiObject.InputEnded` y `Class.GuiObject.InputChanged`.

GuiObject.InputBegan

input

Un `Class.InputObject`, que contiene datos útiles para consultar la entrada del usuario, como el `Enum.UserInputType|tipo de entrada`, `Enum.UserInputState|estado de entrada` y `Class.InputObject.Position|coordenadas de pantalla de la entrada`.

Se activa cuando un usuario comienza a interactuar a través de un dispositivo de interfaz humano-computadora (botón del mouse presionado, inicio de toque, botón del teclado presionado, etc).

El siguiente ejemplo demuestra uno de los muchos ejemplos de uso para manejar la
entrada del usuario desde InputChanged dependiendo de su tipo.
Para que esto funcione como se espera, debe estar colocado en un `LocalScript`
y ser un hijo de _gui_.

Este evento se activa cuando un usuario cambia cómo está interactuando a través de un dispositivo de interfaz humano-computadora (botón del mouse presionado, inicio de toque, botón del teclado presionado, etc).

El `Class.UserInputService` tiene un evento de nombre similar que no está restringido a un elemento de UI específico: `Class.UserInputService.InputChanged`.

Este evento siempre se activará independientemente del estado del juego.

Consulta también `Class.GuiObject.InputBegan` y `Class.GuiObject.InputEnded`.

GuiObject.InputChanged

Se activa cuando un usuario cambia cómo está interactuando a través de un dispositivo de interfaz humano-computadora (botón del mouse presionado, inicio de toque, botón del teclado presionado, etc).

El siguiente ejemplo demuestra uno de muchos ejemplos de uso de manejo de entrada
del usuario desde InputEnded dependiendo de su tipo.

Para que esto funcione como se espera, debe ser colocado en un `LocalScript`
y como un hijo de _gui_.

El evento InputEnded se activa cuando un usuario deja de interactuar a través de un dispositivo de interfaz humano-computadora (botón del mouse presionado, inicio de toque, botón del teclado presionado, etc).

El `Class.UserInputService` tiene un evento de nombre similar que no está restringido a un elemento de UI específico: `Class.UserInputService.InputEnded`.

Este evento siempre se activará independientemente del estado del juego.

Consulta también `Class.GuiObject.InputBegan` y `Class.GuiObject.InputChanged`.

GuiObject.InputEnded

Un `Class.InputObject`, que contiene datos útiles para consultar la entrada del usuario, como el `Enum.UserInputType`, `Enum.UserInputState` y `Class.InputObject.Position`.

Se activa cuando un usuario deja de interactuar a través de un dispositivo de interfaz humano-computadora (botón del mouse presionado, inicio de toque, botón del teclado presionado, etc).

El siguiente ejemplo imprime la ubicación del mouse, en píxeles, cuando entra en el elemento de GUI.

El evento MouseEnter se activa cuando un usuario mueve su mouse dentro de un elemento `Class.GuiObject`.

Por favor, no confíes en los argumentos `x` e `y` pasados por este evento como una forma infalible de determinar dónde está el mouse del usuario cuando entra en una GUI. Estas coordenadas pueden variar incluso cuando el mouse entra en la GUI a través del mismo borde, particularmente cuando el mouse entra en el elemento rápidamente. Esto se debe a que las coordenadas indican la posición del mouse cuando se activa el evento en lugar del momento exacto en que el mouse entra en la GUI.

Este evento se activa incluso cuando el elemento GUI se renderiza debajo de otro elemento.

Si deseas rastrear cuándo el mouse de un usuario sale de un elemento GUI, puedes usar el evento `Class.GuiObject.MouseLeave`.

##### Consulta También

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

GuiObject.MouseEnter

La coordenada de pantalla en píxeles **X** del mouse, relativa a la esquina superior izquierda de la pantalla.

La coordenada de pantalla en píxeles **Y** del mouse, relativa a la esquina superior izquierda de la pantalla.

Se activa cuando un usuario mueve su mouse dentro de un elemento GUI.

El evento MouseLeave se activa cuando un usuario mueve su mouse fuera de un elemento `Class.GuiObject`.

Por favor, no confíes en los argumentos `x` e `y` pasados por este evento como una forma infalible de determinar dónde está el mouse del usuario cuando sale de una GUI. Estas coordenadas pueden variar incluso cuando el mouse sale de la GUI a través del mismo borde, particularmente cuando el mouse sale del elemento rápidamente. Esto se debe a que las coordenadas indican la posición del mouse cuando se activa el evento en lugar del momento exacto en que el mouse sale de la GUI.

Este evento se activa incluso cuando el elemento GUI se renderiza debajo de otro elemento.

##### Consulta También

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

GuiObject.MouseLeave

Se activa cuando un usuario mueve su mouse fuera de un elemento GUI.

Se activa cada vez que un usuario mueve su ratón mientras está dentro de un
`Class.GuiObject`. Es similar a `Class.Mouse.Move`, que
se activa independientemente de si el ratón del usuario está sobre un elemento GUI.

Ten en cuenta que este evento se activa cuando se actualiza la posición del ratón, por lo que
se activará repetidamente mientras se mueve.

Los argumentos `x` e `y` indican las coordenadas de pantalla actualizadas del
ratón del usuario en píxeles. Estos pueden ser útiles para determinar la ubicación del ratón en la GUI, en la pantalla, y el delta desde la posición anterior del ratón
si se está rastreando en una variable global.

El código a continuación demuestra cómo determinar el desplazamiento `Datatype.Vector2`
 del ratón del usuario en relación con un elemento GUI.
`Class.GuiObject.AbsolutePosition|AbsolutePosition` se mide dentro del
inset de la GUI de la pantalla, mientras que los argumentos `x` e `y` de este evento son
coordenadas de pantalla que lo incluyen, por lo que el ejemplo llama a
`Class.GuiService:GetGuiInset()|GetGuiInset()` para reconciliar los dos espacios
en lugar de asumir un tamaño de inset fijo.

```lua
local Players = game:GetService("Players")
local GuiService = game:GetService("GuiService")

local CustomScrollingFrame = script.Parent
local SubFrame = CustomScrollingFrame:FindFirstChild("SubFrame")

local mouse = Players.LocalPlayer:GetMouse()

local function getPosition(X, Y)
	local topLeftInset = GuiService:GetGuiInset()

	local gui_X = CustomScrollingFrame.AbsolutePosition.X
	local gui_Y = CustomScrollingFrame.AbsolutePosition.Y

	local pos = Vector2.new(math.abs(X - gui_X), math.abs(Y - gui_Y - topLeftInset.Y))
	print(pos)
end

CustomScrollingFrame.MouseMoved:Connect(getPosition)
```
Ten en cuenta que este evento puede no activarse exactamente cuando el ratón del usuario entra o
sale de un elemento GUI. Por lo tanto, los argumentos `x` e `y` pueden no coincidir
perfectamente con las coordenadas de los bordes de la GUI.

##### Ver También

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


GuiObject.MouseMoved

Se activa cada vez que un usuario mueve su mouse mientras está dentro de un elemento GUI.

El evento WheelBackward se activa cuando un usuario desplaza su rueda del mouse hacia atrás cuando el mouse está sobre un elemento `Class.GuiObject`. Es similar a `Class.Mouse.WheelBackward`, que se activa independientemente de si el mouse del usuario está sobre un elemento GUI.

Este evento se activa simplemente como un indicador del movimiento hacia atrás de la rueda. Esto significa que los argumentos de coordenadas del mouse `x` e `y` no cambian como resultado de este evento. Estas coordenadas solo cambian cuando el mouse se mueve, lo que se puede rastrear mediante el evento `Class.GuiObject.MouseMoved`.

##### Consulta También

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

GuiObject.MouseWheelBackward

Se activa cuando un usuario desplaza su rueda del mouse hacia atrás cuando el mouse está sobre un elemento GUI.

El evento WheelForward se activa cuando un usuario desplaza su rueda del mouse hacia adelante cuando el mouse está sobre un elemento `Class.GuiObject`. Es similar a `Class.Mouse.WheelForward`, que se activa independientemente de si el mouse del usuario está sobre un elemento GUI.

Este evento se activa simplemente como un indicador del movimiento hacia adelante de la rueda. Esto significa que las coordenadas de mouse **X** y **Y** no cambian como resultado de este evento. Estas coordenadas solo cambian cuando el mouse se mueve, lo que se puede rastrear mediante el evento `Class.GuiObject.MouseMoved`.

##### Consulta También

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

GuiObject.MouseWheelForward

La coordenada **Y** del mouse del usuario.

Se activa cuando un usuario desplaza su rueda del mouse hacia adelante cuando el mouse está sobre un elemento GUI.

El siguiente ejemplo imprime un mensaje cuando el usuario selecciona el objeto con un
gamepad.

Para que esto funcione como se espera, debe estar en un `LocalScript`
y ser un hijo de _gui_.

Este evento se activa cuando el selector del gamepad comienza a enfocarse en el `Class.GuiObject`.

Si deseas verificar cuándo el selector del gamepad deja de enfocarse en el elemento GUI, puedes usar el evento `Class.GuiObject.SelectionLost`.

Cuando una GUI gana el enfoque de selección, el valor de la propiedad `Class.GuiService.SelectedObject|SelectedObject` también cambia al que gana la selección. Para determinar qué GUI ganó la selección, verifica el valor de esta propiedad.

GuiObject.SelectionGained

Se activa cuando el GuiObject está siendo enfocado con el selector del gamepad.

El siguiente ejemplo imprime un mensaje cuando el elemento pierde el foco en
un gamepad.

Para que esto funcione como se espera, debe estar colocado en un `LocalScript`
y ser un hijo de _gui_.

Este evento se activa cuando el selector del gamepad deja de enfocarse en el `Class.GuiObject`.

Si deseas verificar cuándo el selector del gamepad comienza a enfocarse en el elemento GUI, puedes usar el evento `Class.GuiObject.SelectionGained`.

Cuando una GUI pierde el enfoque de selección, el valor de la propiedad `Class.GuiService.SelectionObject|SelectionObject` cambia a `nil` o al elemento GUI que gana el enfoque de selección. Para determinar qué GUI ganó la selección, o si no hay ninguna GUI seleccionada, verifica el valor de esta propiedad.

GuiObject.SelectionLost

Se activa cuando el selector del gamepad deja de enfocarse en el GuiObject.

Este ejemplo de código permite al jugador manipular la posición en la pantalla de algún
elemento UI, como un `Frame`, manteniendo presionado el elemento UI por un breve
momento. Luego, el jugador mueve su dedo y lo suelta. Durante el gesto
el Frame es coloreado de azul con un contorno blanco.

Este evento se activa después de un breve momento cuando el jugador mantiene su dedo sobre el elemento de UI utilizando un dispositivo habilitado para toque. Se activa con una tabla de `Datatype.Vector2` que describe las posiciones de pantalla relativas de los dedos involucrados en el gesto. Además, se activa múltiples veces: `Enum.UserInputState.Begin` después de un breve retraso, `Enum.UserInputState.Change` si el jugador mueve su dedo durante el gesto, y finalmente `Enum.UserInputState.End`. El retraso depende de la plataforma; en Studio es un poco más de un segundo.

GuiObject.TouchLongPress

touchPositions

Un array de `Datatype.Vector2` que describe las posiciones **relativas** de los dedos involucrados en el gesto.

state

Un `Enum.UserInputState` que describe el estado del gesto:

- Begin se activa una vez al comienzo del gesto (después del breve retraso)
- Change se activa si el jugador mueve su dedo mientras presiona
- End se activa una vez al final del gesto cuando suelta su dedo.

Se activa cuando el jugador comienza, continúa y deja de presionar prolongadamente el elemento de UI.

Este ejemplo de código está destinado a ser colocado en un `LocalScript` dentro de un
`Frame` que está dentro de un `Frame` exterior, u otro `GuiObject`. Permite al
jugador manipular la posición del marco interno al mover su dedo sobre
el marco exterior.

Este evento se activa cuando el jugador mueve su dedo sobre el elemento de UI utilizando un dispositivo habilitado para toque. Se activa poco antes de que `Class.GuiObject.TouchSwipe` lo haría, y no se activa con `Class.GuiObject.TouchTap`. Este evento es útil para permitir que el jugador manipule la posición de los elementos de UI en la pantalla.

Este evento se activa con una tabla de `Datatype.Vector2` que describe las posiciones de pantalla relativas de los dedos involucrados en el gesto. Además, se activa múltiples veces: `Enum.UserInputState.Begin` después de un breve retraso, `Enum.UserInputState.Change` cuando el jugador mueve su dedo durante el gesto, y finalmente con `Enum.UserInputState.End`.

GuiObject.TouchPan

Un array de Luau de objetos `Datatype.Vector2`, cada uno indicando la posición de todos los dedos involucrados en el gesto.

totalTranslation

Indica cuán lejos ha ido el gesto de paneo desde su punto de partida.

velocity

Indica cuán rápido se está realizando el gesto en cada dimensión.

Indica el `Enum.UserInputState` del gesto.

Se activa cuando el jugador mueve su dedo sobre el elemento de UI.

Este ejemplo de código está destinado a un `LocalScript` dentro de un `Frame` interno que está
dentro de un `Frame` externo, u otro `GuiObject`. Permite al jugador escalar
el marco interno realizando un gesto de `Class.GuiObject.TouchPinch` en el
marco exterior.

Este evento se activa cuando el jugador utiliza dos dedos para hacer un gesto de pellizco o tirón en el elemento de la interfaz de usuario utilizando un dispositivo con pantalla táctil. Un **pellizco** ocurre cuando dos o más dedos se acercan, y un **tirón** ocurre cuando se separan. Este evento se activa junto con `Class.GuiObject.TouchPan`. Este evento es útil para permitir que el jugador manipule la escala (tamaño) de los elementos de la interfaz de usuario en la pantalla, y se utiliza con mayor frecuencia para funciones de zoom.

Este evento se activa con una tabla de `Datatype.Vector2` que describe las posiciones relativas en la pantalla de los dedos involucrados en el gesto. Además, se activa varias veces: `Enum.UserInputState.Begin` después de un breve retraso, `Enum.UserInputState.Change` cuando el jugador mueve un dedo durante el gesto, y finalmente con `Enum.UserInputState.End`. Se debe tener en cuenta que la escala debe usarse **multiplicativamente**.

GuiObject.TouchPinch

Un array de Luau de objetos `Datatype.Vector2`, cada uno indicando la posición de todos los dedos involucrados en el gesto de pellizco.

scale

Un flotante que indica la diferencia desde el inicio del gesto de pellizco.

Un flotante que indica qué tan rápido está ocurriendo el gesto de pellizco.

Se activa cuando el jugador realiza un gesto de pellizco o tirón utilizando dos dedos sobre el elemento de UI.

Este ejemplo de código está destinado a un `LocalScript` dentro de un `Frame` interno que está
dentro de un `Frame` externo, u otro `GuiObject`. Permite al jugador rotar
el marco interno realizando un gesto de `Class.GuiObject.TouchRotate` en el
marco externo.

Este evento se activa cuando el jugador utiliza dos dedos para hacer un gesto de rotación en el elemento de la interfaz de usuario utilizando un dispositivo con pantalla táctil. La rotación ocurre cuando el ángulo de la línea entre dos dedos cambia. Este evento se activa junto con `Class.GuiObject.TouchPan`. Este evento es útil para permitir que el jugador manipule la rotación de los elementos de la interfaz de usuario en la pantalla.

Este evento se activa con una tabla de `Datatype.Vector2` que describe las posiciones relativas en la pantalla de los dedos involucrados en el gesto. Además, se activa varias veces: `Enum.UserInputState.Begin` después de un breve retraso, `Enum.UserInputState.Change` cuando el jugador mueve un dedo durante el gesto, y finalmente con `Enum.UserInputState.End`.

GuiObject.TouchRotate

rotation

Un flotante que indica cuánto ha cambiado la rotación desde el inicio del gesto.

Un flotante que indica qué tan rápido se está realizando el gesto.

Se activa cuando el jugador realiza un gesto de rotación utilizando dos dedos en el elemento de la interfaz de usuario.

Este ejemplo de código hará que un `Frame` (u otro `GuiObject`) rebote cuando se realice un gesto de deslizamiento en un dispositivo con pantalla táctil (o el emulador de Studio).
Deslizamientos horizontales cambiarán el matiz de la
`Class.GuiObject.BackgroundColor3`, mientras que los deslizamientos verticales cambiarán la
saturación.

Este evento se activa cuando el jugador realiza un gesto de deslizamiento en el elemento de la interfaz de usuario utilizando un dispositivo con pantalla táctil. Se activa con la dirección del gesto (Arriba, Abajo, Izquierda o Derecha) y el número de puntos de contacto involucrados en el gesto. Los gestos de deslizamiento se utilizan a menudo para cambiar de pestañas en las interfaces de usuario móviles.

GuiObject.TouchSwipe

swipeDirection

Un `Enum.SwipeDirection` que indica la dirección del gesto de deslizamiento (Arriba, Abajo, Izquierda o Derecha).

numberOfTouches

El número de puntos de contacto involucrados en el gesto (generalmente 1).

Se activa cuando el jugador realiza un gesto de deslizamiento en el elemento de la interfaz de usuario.

Este ejemplo de código alternará el `Class.GuiObject.BackgroundTransparency` de un
elemento de UI, como un `Frame`, cuando se toque en un dispositivo habilitado para táctil.

Este evento se activa cuando el jugador realiza un gesto de toque en el elemento de la interfaz de usuario utilizando un dispositivo con pantalla táctil. Un toque es un contacto rápido y único sin ningún movimiento involucrado (una presión más larga activaría `Class.GuiObject.TouchLongPress`, y moverse durante el toque activaría `Class.GuiObject.TouchPan` y/o `Class.GuiObject.TouchSwipe`). Se activa con una tabla de objetos `Datatype.Vector2` que describen las posiciones relativas de los dedos involucrados en el gesto.

GuiObject.TouchTap

Un array de `Datatype.Vector2` que describe las **posiciones** relativas de los dedos involucrados en el gesto.

Se activa cuando el jugador realiza un gesto de toque en el elemento de la interfaz de usuario.

Este ejemplo de código demuestra un uso más detallado de TweenPosition al
detectar cuándo se completa/cancela el tween definiendo una función de callback. También
imprime si el tween se reproducirá.

Mueve suavemente una GUI a una nueva posición `Datatype.UDim2` en el tiempo especificado utilizando la `Enum.EasingDirection` y `Enum.EasingStyle` especificadas.

Esta función devolverá si el tween se reproducirá. No se reproducirá si otro tween está actuando sobre el `Class.GuiObject` y el parámetro de anulación es `false`.

Consulta también `Class.GuiObject:TweenSize()` y `Class.GuiObject:TweenSizeAndPosition()`.

GuiObject:TweenPosition

endPosition

easingDirection

La dirección en la que se debe suavizar la GUI hacia la _endPosition_.

easingStyle

El estilo en el que se debe suavizar la GUI hacia la _endPosition_.

time

Cuánto tiempo, en segundos, debe tardar el tween en completarse.

override

Si el tween anulará un tween en progreso.

callback

Una función de callback para ejecutar cuando el tween se complete.

Mueve suavemente una GUI a un nuevo `Datatype.UDim2`.

Este ejemplo de código demuestra el uso de la función `Class.GuiObject:TweenSize()`
. Inicia una animación en la propiedad `Class.GuiObject.Size` del padre
a `UDim2.new(0.5, 0, 0.5, 0)`, que es la mitad del tamaño del
padre del `GuiObject` en ambos ejes.

Además, demuestra cómo se puede usar el parámetro de callback para detectar
cuándo se detiene la interpolación (ya sea que fue cancelada por otra interpolación o completada).

Redimensiona suavemente un `Class.GuiObject` a un nuevo `Datatype.UDim2` en el tiempo especificado utilizando la `Enum.EasingDirection` y `Enum.EasingStyle` especificadas.

Esta función devolverá si el tween se reproducirá. Normalmente esto siempre devolverá `true`, pero devolverá `false` si otro tween está activo y la anulación está establecida en `false`.

Consulta también `Class.GuiObject:TweenSize()` y `Class.GuiObject:TweenSizeAndPosition()`.

GuiObject:TweenSize

endSize

El tamaño al que la GUI debe redimensionarse.

La dirección en la que se debe suavizar la GUI hacia el _endSize_.

El estilo en el que se debe suavizar la GUI hacia el _endSize_.

Redimensiona suavemente un `Class.GuiObject` a un nuevo `Datatype.UDim2`.

El siguiente ejemplo animará un `Class.Frame` a la esquina superior izquierda del padre's
tamaño y lo redimensionará a 0.

Redimensiona y mueve suavemente una GUI a un nuevo tamaño y posición `Datatype.UDim2` en el tiempo especificado utilizando la `Enum.EasingDirection` y `Enum.EasingStyle` especificadas.

Esta función devolverá si el tween se reproducirá. Normalmente esto siempre devolverá `true`, pero devolverá `false` si otro tween está activo y la anulación está establecida en `false`.

Consulta también `Class.GuiObject:TweenSize()` y `Class.GuiObject:TweenSizeAndPosition()`.

GuiObject:TweenSizeAndPosition

La dirección en la que se debe suavizar la GUI hacia el _endSize_ y _endPosition_.

El estilo en el que se debe suavizar la GUI hacia el _endSize_ y _endPosition_.

Mueve suavemente una GUI a un nuevo tamaño y posición.

GuiObject

Este ejemplo de código demuestra el uso de la propiedad Activo como un debounce
para el evento Activado.

Esta propiedad determina si el `Class.GuiObject` recibirá entrada en el espacio 3D, como modelos subyacentes con una clase `Class.ClickDetector` como `Class.DragDetector`.

Para objetos `Class.GuiButton` (`Class.ImageButton` y `Class.TextButton`), esta propiedad determina si se activa `Class.GuiButton.Activated|Activated` (`Class.GuiButton.AutoButtonColor|AutoButtonColor` seguirá funcionando para ellos también). Los eventos `Class.GuiObject.InputBegan|InputBegan`, `Class.GuiObject.InputChanged|InputChanged` y `Class.GuiObject.InputEnded|InputEnded` funcionan normalmente sin importar el valor de esta propiedad.

GuiObject.Active

Determina si este elemento de UI recibe entrada.

Este código mueve un elemento de UI a diferentes lados del elemento padre.
Comienza en la parte superior izquierda y termina en la parte inferior derecha. Pega esto en un
LocalScript en un Frame, dentro de un ScreenGui.

Esta propiedad determina el punto de origen de un `Class.GuiObject`, relativo a su tamaño absoluto. El punto de origen determina desde dónde se posiciona el elemento (a través de `Class.GuiObject.Position`) y desde dónde se expande el `Class.GuiObject.Size` renderizado.

Consulta [aquí](/ui/position-and-size#anchorpoint) para diagramas ilustrados y detalles.

GuiObject.AnchorPoint

Determina el punto de origen de un `Class.GuiObject`, relativo a su tamaño absoluto.

El siguiente script crea un marco padre de tamaño automático con
un `UIListLayout`, luego inserta varios objetos `TextLabel` de
tamaño automático. Nota cómo el `UIListLayout` padre cambia de tamaño automáticamente para ajustarse a su
contenido hijo y las etiquetas se redimensionan automáticamente para ajustarse a su contenido de texto.
Este script se puede incorporar a un `ScreenGui`.

Esta propiedad se utiliza para ajustar automáticamente el tamaño de los objetos de UI padre en función del tamaño de sus descendientes. Puedes usar esta propiedad para agregar dinámicamente texto y otro contenido a un objeto de UI en tiempo de edición o ejecución, y el tamaño se ajustará para adaptarse a ese contenido.

Cuando `Class.GuiObject.AutomaticSize|AutomaticSize` se establece en un valor de `Enum.AutomaticSize` diferente de `Enum.AutomaticSize|None`, este objeto de UI puede cambiar de tamaño dependiendo de su contenido hijo.

Para más información sobre cómo usar esta propiedad y cómo funciona, consulta [aquí](/ui/size-modifiers#automatic-sizing).

GuiObject.AutomaticSize

Determina si el cambio de tamaño ocurre en función del contenido hijo.

Determina el color de fondo del `Class.GuiObject`.

GuiObject.BackgroundColor

Este ejemplo de código hace que un Frame padre recorra todos los colores del arcoíris usando Color3.fromHSV.

Esta propiedad determina el color de fondo de un `Class.GuiObject` (el color de relleno). Si tu elemento contiene texto, como un `Class.TextBox`, `Class.TextButton` o `Class.TextLabel`, asegúrate de que el color de tu fondo contraste con el color del texto.

Otra propiedad que determina las propiedades visuales del fondo es `Class.GuiObject.BackgroundTransparency`; si se establece en `1`, ni el fondo ni el borde se renderizarán.

Consulta también `Class.GuiObject.BorderColor3|BorderColor3`.

GuiObject.BackgroundColor3

Esta propiedad determina la transparencia del fondo y el borde del `Class.GuiObject`. Sin embargo, no determina la transparencia del texto si la GUI es un `Class.TextBox`, `Class.TextButton` o `Class.TextLabel`; la transparencia del texto se determina por `Class.TextBox.TextTransparency`, `Class.TextButton.TextTransparency` y `Class.TextLabel.TextTransparency` respectivamente.

Si esta propiedad se establece en `1`, ni el fondo ni el borde se renderizarán y el fondo de la GUI será completamente transparente.

GuiObject.BackgroundTransparency

Determina la transparencia del fondo y el borde del `Class.GuiObject`.

Determina el color del borde del `Class.GuiObject`.

GuiObject.BorderColor

Este código de ejemplo hace que el borde de un GuiObject padre se resalte cuando el
usuario pasa el ratón sobre el elemento.

Determina el color del borde rectangular del `Class.GuiObject` (también conocido como el color del trazo). Esto es independiente del `Class.GuiObject.BackgroundColor3` del objeto. No podrás ver el borde del objeto si su propiedad `Class.GuiObject.BorderSizePixel` se establece en `0`.

Ten en cuenta que el componente `Class.UIStroke` permite efectos de borde más avanzados.

GuiObject.BorderColor3

Esta propiedad determina de qué manera se dispone el borde del `Class.GuiObject` en relación con sus dimensiones utilizando el enum del mismo nombre, `Enum.BorderMode`.

Ten en cuenta que `Class.UIStroke` puede anular esta propiedad y permitir efectos de borde más avanzados.

GuiObject.BorderMode

Determina de qué manera se dispone el borde del `Class.GuiObject` en relación con sus dimensiones.

Esta propiedad determina cuán ancho se renderiza el borde del `Class.GuiObject`, en píxeles. Establecer esto en 0 desactiva completamente el borde.

Ten en cuenta que `Class.UIStroke` puede anular esta propiedad y permitir efectos de borde más avanzados.

GuiObject.BorderSizePixel

Determina el ancho en píxeles del borde del `Class.GuiObject`.

Esta propiedad determina si el `Class.GuiObject` recortará (hará invisible) cualquier parte de los elementos GUI descendientes que de otro modo se renderizarían fuera de los límites del rectángulo.

#### Comportamiento de Rotación

Cuando `Class.StarterGui.ClipsDescendantsSupportsRotation` está habilitado, el recorte funciona correctamente para formas rotadas. Sin embargo, el recorte **por** formas rotadas (cuando el padre de recorte en sí está rotado) o por esquinas redondeadas (`Class.UICorner`) no es compatible.

Cuando `Class.StarterGui.ClipsDescendantsSupportsRotation` **no** está habilitado y este `Class.GuiObject` o cualquier ancestro `Class.GuiObject` tiene una `Class.GuiObject.Rotation|Rotation` **diferente de cero**, esta propiedad es **ignorada** y los elementos GUI descendientes se renderizarán independientemente del valor de esta propiedad.

GuiObject.ClipsDescendants

Determina si los `Class.GuiObject|GuiObjects` descendientes fuera de los límites de un elemento GUI padre deben renderizarse.

Esto indica si un `Class.GuiObject` (y sus descendientes) se puede arrastrar por la pantalla.

GuiObject.Draggable

Determina si un `Class.GuiObject` (y sus descendientes) se puede arrastrar por la pantalla.

Cuando el dedo del jugador está siendo tocado y mantenido sobre el `Class.GuiObject`, el `Class.GuiObject.GuiState|GuiState` del `Class.GuiObject` se establecerá en `Enum.GuiState.Press|Press`. De manera similar, cuando el dedo del jugador se libera del `Class.GuiObject`, el `Class.GuiObject.GuiState|GuiState` del `Class.GuiObject` se establecerá en `Enum.GuiState.Idle|Idle`, y cuando `Class.GuiObject.Interactable|Interactable` se desactiva en el `Class.GuiObject`, el `Class.GuiState` del `Class.GuiObject` se establecerá en `Enum.GuiState.NonInteractable|NonInteractable`.

GuiObject.GuiState

Determina si el mouse del jugador está siendo presionado activamente sobre el `Class.GuiObject` o no.

Controla si, y en qué medida, el `Class.GuiObject` recibe entrada que ocurre sobre él, utilizando `Enum.InputSink`. Recibir entrada evita que pase a través de objetos detrás del elemento, incluidos objetos 3D en el mundo como aquellos con un `Class.ClickDetector` o `Class.DragDetector`. Por defecto es `Enum.InputSink.None`, excepto en objetos `Class.GuiButton` (`Class.ImageButton` y `Class.TextButton`), donde por defecto es `Enum.InputSink.Activate`.

- `Enum.InputSink.None` — el objeto no recibe entrada por sí mismo.
- `Enum.InputSink.Activate` — el objeto recibe la entrada de presión de botón del mouse y toque utilizada para activarlo, pero permite que otra entrada (como el movimiento del mouse) pase.
- `Enum.InputSink.All` — el objeto recibe toda la entrada que ocurre sobre él.

Esta propiedad es un sucesor más granular de la propiedad booleana `Class.GuiObject.Active|Active`, que solo puede recibir toda la entrada o ninguna. Los eventos `Class.GuiObject.InputBegan|InputBegan`, `Class.GuiObject.InputChanged|InputChanged` y `Class.GuiObject.InputEnded|InputEnded` se activan independientemente del valor de esta propiedad.

GuiObject.InputSink

Controla si, y cómo, el `Class.GuiObject` recibe entrada que ocurre sobre él.

Determina si el `Class.GuiButton` se puede interactuar o no, o si el `Enum.GuiState|GuiState` del `Class.GuiObject` está cambiando o no.

En un `Class.GuiButton`:

- Cuando la configuración `Class.GuiObject.Interactable|Interactable` en el `Class.GuiButton` se establece en `false`, el `Class.GuiButton` ya no podrá ser presionado o clicado, y el `Class.GuiObject.GuiState|GuiState` se establecerá constantemente en `Enum.GuiState.NonInteractable|NonInteractable`.
- Cuando la configuración `Class.GuiObject.Interactable|Interactable` en el `Class.GuiButton` se establece en `true`, el `Class.GuiButton` se comportará normalmente nuevamente y el `Class.GuiObject.GuiState|GuiState` se comportará normalmente.

En un `Class.GuiObject`:

- Cuando la configuración `Class.GuiObject.Interactable|Interactable` en el `Class.GuiButton` se establece en `false`, el `Class.GuiObject.GuiState|GuiState` se establecerá constantemente en `Enum.GuiState.NonInteractable|NonInteractable`.
- Cuando la configuración `Class.GuiObject.Interactable|Interactable` en el `Class.GuiButton` se establece en `true`, el `Class.GuiObject.GuiState|GuiState` se comportará normalmente nuevamente.

GuiObject.Interactable

Determina si el `Class.GuiButton` se puede interactuar o no, o si el `Enum.GuiState|GuiState` del `Class.GuiObject` está cambiando o no.

Esta propiedad controla el orden de clasificación del `Class.GuiObject` al usar un `Class.UIGridStyleLayout` (como `Class.UIListLayout` o `Class.UIPageLayout`) con `Class.UIGridStyleLayout.SortOrder|SortOrder` establecido en `Enum.SortOrder.LayoutOrder`. No tiene funcionalidad si el objeto no tiene una estructura de diseño de UI hermana.

`Class.GuiObject|GuiObjects` se ordenan en orden ascendente donde los valores más bajos tienen prioridad sobre los valores más altos. Los objetos con valores iguales vuelven al orden en que fueron añadidos.

Si no estás seguro de si necesitarás agregar un elemento entre dos elementos existentes en el futuro, es una buena práctica usar múltiplos de `100` (`0`, `100`, `200`, etc.). Esto asegura un gran espacio de valores de orden de diseño que puedes usar para elementos ordenados entre otros elementos.

Consulta también `Class.GuiObject.ZIndex|ZIndex` que determina el orden de **renderizado** del objeto en lugar del orden de clasificación.

GuiObject.LayoutOrder

Controla el orden de clasificación del `Class.GuiObject` cuando se usa con un `Class.UIGridStyleLayout`.

Este ejemplo demuestra cómo habilitar la navegación con gamepad a través de una cuadrícula de
`GuiObject|GUI` elementos sin tener que conectar manualmente los
`Class.GuiObject.NextSelectionUp`, `Class.GuiObject.NextSelectionDown`, y
`GuiObject|NextSelectionRight`, y `Class.GuiObject.NextSelectionLeft`
propiedades para cada elemento en la cuadrícula.

Ten en cuenta que este código asume que tu `UIGridLayout` está ordenado por
`Class.UIGridLayout.SortOrder|name`, donde los elementos están nombrados en orden numérico sucesivo.

El código se basa en esto para establecer las propiedades NextSelection para todos
`GuiObjects` en el mismo nivel que el UIGridLayout. En nuestro ejemplo, el
UIGridLayoutObject y los elementos de GUI dentro de la cuadrícula son todos hijos de un
`Frame` llamado _"Container"_. El código
`Class.Instance:GetChildren()|obtiene los hijos` de _"Container"_ y recorre
cada hijo. Los hijos que no son GuiObjects son ignorados. Para cada elemento de GUI,
el código intenta asignar las propiedades NextSelection utilizando la
siguiente lógica:

1. Comenzando con 1, el nombre de todos los elementos de GUI coincide con su posición en la
   cuadrícula
2. Izquierda: El elemento a la izquierda siempre será numerado 1 menos que el actual
   elemento
3. Derecha: El elemento a la derecha siempre será numerado 1 más que el actual
   elemento
4. Arriba: El elemento arriba (hacia arriba) siempre será el número de GUIs en una fila 1 menos que
   el actual elemento
5. Abajo: El elemento abajo (hacia abajo) siempre será el número de GUIs en una fila más
   que el actual elemento. Esta lógica también permite que los elementos de GUI en el
   comienzo y final de las filas (excluyendo el primer y último elemento) se envuelvan
   a las filas siguiente y anterior. Si un elemento no existe a la
   izquierda, derecha, arriba, o abajo, el NextSelection permanecerá nil y mover el
   selector del Gamepad en esa dirección no cambiará el GUI seleccionado.

Este ejemplo también contiene código para probar la cuadrícula usando las teclas de flecha (Arriba,
Abajo, Izquierda, Derecha) de tu teclado en lugar de un gamepad, por si acaso no
tienes un gamepad para probar. Esta parte del código selecciona inicialmente el
elemento llamado _"1"_ asignándolo a la propiedad `Class.GuiService.SelectedObject`.

Esta propiedad establece el `Class.GuiObject` seleccionado cuando el usuario mueve el selector del [gamepad](/input/gamepad) hacia abajo. Si esta propiedad está vacía, mover el gamepad hacia abajo no cambiará la GUI seleccionada.

Mover el selector del gamepad hacia abajo establece el `Class.GuiService.SelectedObject` en este objeto a menos que la GUI no sea `Class.GuiObject.Selectable|Selectable`. Ten en cuenta que esta propiedad se puede establecer en un elemento de GUI incluso si no es `Class.GuiObject.Selectable|Selectable`, por lo que debes asegurarte de que el valor de la propiedad seleccionable de una GUI coincida con tu comportamiento esperado.

Consulta también `Class.GuiObject.NextSelectionUp|NextSelectionUp`, `Class.GuiObject.NextSelectionLeft|NextSelectionLeft` y `Class.GuiObject.NextSelectionRight|NextSelectionRight`.

GuiObject.NextSelectionDown

Establece el `Class.GuiObject` que se seleccionará cuando el selector del gamepad se mueva hacia abajo.

Esta propiedad establece el `Class.GuiObject` seleccionado cuando el usuario mueve el selector del [gamepad](/input/gamepad) hacia la izquierda. Si esta propiedad está vacía, mover el gamepad hacia la izquierda no cambiará la GUI seleccionada.

Mover el selector del gamepad hacia la izquierda establece el `Class.GuiService.SelectedObject` en este objeto a menos que la GUI no sea `Class.GuiObject.Selectable|Selectable`. Ten en cuenta que esta propiedad se puede establecer en un elemento de GUI incluso si no es `Class.GuiObject.Selectable|Selectable`, por lo que debes asegurarte de que el valor de la propiedad seleccionable de una GUI coincida con tu comportamiento esperado.

Consulta también `Class.GuiObject.NextSelectionUp|NextSelectionUp`, `Class.GuiObject.NextSelectionDown|NextSelectionDown` y `Class.GuiObject.NextSelectionRight|NextSelectionRight`.

GuiObject.NextSelectionLeft

Establece el `Class.GuiObject` que se seleccionará cuando el selector del gamepad se mueva hacia la izquierda.

Esta propiedad establece el `Class.GuiObject` seleccionado cuando el usuario mueve el selector del [gamepad](/input/gamepad) hacia la derecha. Si esta propiedad está vacía, mover el gamepad hacia la derecha no cambiará la GUI seleccionada.

Mover el selector del gamepad hacia la derecha establece el `Class.GuiService.SelectedObject` en este objeto a menos que la GUI no sea `Class.GuiObject.Selectable|Selectable`. Ten en cuenta que esta propiedad se puede establecer en un elemento de GUI incluso si no es `Class.GuiObject.Selectable|Selectable`, por lo que debes asegurarte de que el valor de la propiedad seleccionable de una GUI coincida con tu comportamiento esperado.

Consulta también `Class.GuiObject.NextSelectionUp|NextSelectionUp`, `Class.GuiObject.NextSelectionDown|NextSelectionDown` y `Class.GuiObject.NextSelectionLeft|NextSelectionLeft`.

GuiObject.NextSelectionRight

Establece el `Class.GuiObject` que se seleccionará cuando el selector del gamepad se mueva hacia la derecha.

Una clase abstracta para todos los objetos de interfaz de usuario 2D.

/reference/engine/classes/TextChannelWindow.yaml

Resumen