`Class.TextChannelWindow` est un `Class.GuiObject` qui rend les messages de chat textuels en expérience
provenant d'un `Class.TextChannel` lié. Placez-le sous un
`Class.ScreenGui` ou un autre descendant de `Class.LayerCollector` pour afficher le chat
à un emplacement et une mise en page personnalisés.

Définissez `Class.TextChannelWindow.Target|Target` sur un `Class.TextChannel` pour choisir
les messages du canal que la fenêtre affiche. La fenêtre s'enregistre auprès de
`Class.TextChatService` lorsqu'elle est ajoutée au modèle de données.

Les propriétés définies sur `Class.ChatWindowConfiguration` ne s'appliquent pas à cette fenêtre.

Enfants acceptés : `Class.UICorner`, `Class.UIAspectRatioConstraint`,
`Class.UISizeConstraint`, et des scripts (`Class.LocalScript`, `Class.Script`,
`Class.ModuleScript`); d'autres types d'enfants sont rejetés.


TextChannelWindow

Une référence au `Class.TextChannel` dont les messages cette fenêtre rend.
Lorsqu'elle est définie, la fenêtre affiche les messages du canal spécifié. Définir
cette propriété sur `nil` déconnecte la fenêtre de tout canal afin qu'elle
n'affiche aucun message.

La valeur par défaut est `nil` (aucun canal lié).

TextChannelWindow.Target

Affiche le canal RBXGeneral dans une fenêtre personnalisée avec une police non par défaut. Collez
dans un LocalScript.


Police utilisée pour rendre les messages de cette fenêtre et sa barre d'entrée. Appliquée uniquement
lorsque `Class.TextChannelWindow.UseDefaultFont` est `false`.


TextChannelWindow.FontFace

Police utilisée pour rendre le texte dans cette fenêtre.


Lorsque `true` (par défaut), la fenêtre utilise la police par défaut de la plateforme en direct.
Lorsque `false`, la fenêtre utilise `Class.TextChannelWindow.FontFace|FontFace`.


TextChannelWindow.UseDefaultFont

Indique si cette fenêtre utilise la police par défaut de la plateforme en direct.


`Class.GuiObject` est une classe abstraite (tout comme `Class.BasePart`) pour un objet d'interface utilisateur 2D. Elle définit toutes les propriétés relatives à l'affichage d'un objet d'interface utilisateur graphique (GUI) tel que `Class.GuiObject.Size|Size` et `Class.GuiObject.Position|Position`. Elle possède également des propriétés en lecture seule utiles comme `Class.GuiObject.AbsolutePosition|AbsolutePosition`, `Class.GuiObject.AbsoluteSize|AbsoluteSize`, et `Class.GuiObject.AbsoluteRotation|AbsoluteRotation`.

Pour manipuler la disposition des objets GUI de manière spéciale, vous pouvez utiliser une structure de mise en page telle que [list/flex](/ui/list-flex-layouts) ou [grid](/ui/grid-table-layouts), et vous pouvez les styliser au-delà de leurs propriétés de base grâce aux [modificateurs d'apparence](/ui/appearance-modifiers).

Bien qu'il soit possible de détecter les événements de bouton de souris sur n'importe quel objet GUI en utilisant `Class.GuiObject.InputBegan|InputBegan` et `Class.GuiObject.InputEnded|InputEnded`, seuls `Class.ImageButton` et `Class.TextButton` ont des événements dédiés pratiques tels que `Class.TextButton.Activated|Activated` pour détecter un clic/appui.

L'exemple ci-dessous suppose qu'il est dans un GuiObject tel qu'un `TextButton`, et
que la propriété `Class.GuiObject.Draggable` est définie sur true. Il imprimera
le UDim2 à partir duquel le joueur a commencé à faire glisser l'objet.

Cet événement se déclenche lorsqu'un joueur commence à faire glisser l'objet.

Voir aussi `Class.GuiObject.DragStopped`.

GuiObject.DragBegin

initialPosition

Une valeur `Datatype.UDim2` de la position du `Class.GuiObject` avant le début de toute opération de glissement.

Déclenché lorsqu'un joueur commence à faire glisser l'objet.

L'exemple ci-dessous suppose qu'il se trouve dans un GuiObject tel qu'un `TextButton`, et
que la propriété `Class.GuiObject.Draggable` est définie sur true. Il imprimera
les coordonnées X et Y où le joueur a arrêté de faire glisser le GUI. Par exemple, si le
joueur arrêtait de faire glisser l'objet à 189, 180, cela imprimerait Le
joueur a arrêté de faire glisser le GuiObject à (189, 180)


Cet événement se déclenche lorsqu'un joueur arrête de faire glisser l'objet.

Voir aussi `Class.GuiObject.DragBegin`.

GuiObject.DragStopped

La position **X** de la souris à l'écran en pixels, par rapport au coin supérieur gauche de l'écran.

La position **Y** de la souris à l'écran en pixels, par rapport au coin supérieur gauche de l'écran.

Déclenché lorsqu'un joueur arrête de faire glisser l'objet.

L'exemple suivant démontre l'un des nombreux exemples d'utilisation de la gestion de l'entrée utilisateur
à partir de InputBegan en fonction de son type.

Pour que cela fonctionne comme prévu, cela doit être placé dans un `LocalScript`
et un enfant de _gui_.


Cet événement se déclenche lorsqu'un utilisateur commence à interagir avec le `Class.GuiObject` via un dispositif d'interface homme-machine (bouton de souris enfoncé, début de toucher, bouton de clavier enfoncé, etc).

Le `Class.UserInputService` a un événement de nom similaire qui n'est pas restreint à un élément UI spécifique : `Class.UserInputService.InputBegan`.

Cet événement se déclenche toujours indépendamment de l'état du jeu.

Voir aussi `Class.GuiObject.InputEnded` et `Class.GuiObject.InputChanged`.

GuiObject.InputBegan

input

Un `Class.InputObject`, qui contient des données utiles pour interroger l'entrée utilisateur telles que le `Enum.UserInputType|type d'entrée`, `Enum.UserInputState|état de l'entrée`, et `Class.InputObject.Position|coordonnées à l'écran de l'entrée`.

Déclenché lorsqu'un utilisateur commence à interagir via un dispositif d'interface homme-machine (bouton de souris enfoncé, début de toucher, bouton de clavier enfoncé, etc).

L'exemple suivant illustre l'un des nombreux exemples d'utilisation de la gestion de l'
intrant utilisateur à partir d'InputChanged selon son type.

Pour que cela fonctionne comme prévu, il doit être placé dans un `LocalScript`
et un enfant de _gui_.

Cet événement se déclenche lorsqu'un utilisateur change la façon dont il interagit via un dispositif d'interface homme-machine (bouton de souris enfoncé, début de toucher, bouton de clavier enfoncé, etc).

Le `Class.UserInputService` a un événement de nom similaire qui n'est pas restreint à un élément UI spécifique : `Class.UserInputService.InputChanged`.

Cet événement se déclenche toujours indépendamment de l'état du jeu.

Voir aussi `Class.GuiObject.InputBegan` et `Class.GuiObject.InputEnded`.

GuiObject.InputChanged

Déclenché lorsqu'un utilisateur change la façon dont il interagit via un dispositif d'interface homme-machine (bouton de souris enfoncé, début de toucher, bouton de clavier enfoncé, etc).

L'exemple suivant démontre l'un des nombreux exemples d'utilisation de la gestion de l'entrée utilisateur
à partir de InputEnded en fonction de son type.

Pour que cela fonctionne comme prévu, cela doit être placé dans un `LocalScript`
et un enfant de _gui_.


L'événement InputEnded se déclenche lorsqu'un utilisateur arrête d'interagir via un dispositif d'interface homme-machine (bouton de souris enfoncé, début de toucher, bouton de clavier enfoncé, etc).

Le `Class.UserInputService` a un événement de nom similaire qui n'est pas restreint à un élément UI spécifique : `Class.UserInputService.InputEnded`.

Cet événement se déclenche toujours indépendamment de l'état du jeu.

Voir aussi `Class.GuiObject.InputBegan` et `Class.GuiObject.InputChanged`.

GuiObject.InputEnded

Un `Class.InputObject`, qui contient des données utiles pour interroger l'entrée utilisateur telles que le `Enum.UserInputType`, `Enum.UserInputState`, et `Class.InputObject.Position`.

Déclenché lorsqu'un utilisateur arrête d'interagir via un dispositif d'interface homme-machine (bouton de souris enfoncé, début de toucher, bouton de clavier enfoncé, etc).

L'exemple suivant imprime l'emplacement de la souris, en pixels, lorsqu'elle entre dans un élément GUI.


L'événement MouseEnter se déclenche lorsqu'un utilisateur déplace sa souris dans un élément `Class.GuiObject`.

Veuillez ne pas vous fier aux arguments `x` et `y` passés par cet événement comme moyen infaillible de déterminer où se trouve la souris de l'utilisateur lorsqu'elle entre dans un GUI. Ces coordonnées peuvent varier même lorsque la souris entre dans le GUI par le même bord - en particulier lorsque la souris entre rapidement dans l'élément. Cela est dû au fait que les coordonnées indiquent la position de la souris lorsque l'événement se déclenche plutôt que le moment exact où la souris entre dans le GUI.

Cet événement se déclenche même lorsque l'élément GUI est rendu sous un autre élément.

Si vous souhaitez suivre quand la souris d'un utilisateur quitte un élément GUI, vous pouvez utiliser l'événement `Class.GuiObject.MouseLeave`.

##### Voir aussi

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

GuiObject.MouseEnter

La coordonnée **X** de la souris à l'écran en pixels, par rapport au coin supérieur gauche de l'écran.

La coordonnée **Y** de la souris à l'écran en pixels, par rapport au coin supérieur gauche de l'écran.

Se déclenche lorsqu'un utilisateur déplace sa souris dans un élément GUI.

L'événement MouseLeave se déclenche lorsqu'un utilisateur déplace sa souris hors d'un élément `Class.GuiObject`.

Veuillez ne pas vous fier aux arguments `x` et `y` passés par cet événement comme moyen infaillible de déterminer où se trouve la souris de l'utilisateur lorsqu'elle quitte un GUI. Ces coordonnées peuvent varier même lorsque la souris quitte le GUI par le même bord - en particulier lorsque la souris quitte rapidement l'élément. Cela est dû au fait que les coordonnées indiquent la position de la souris lorsque l'événement se déclenche plutôt que le moment exact où la souris quitte le GUI.

Cet événement se déclenche même lorsque l'élément GUI est rendu sous un autre élément.

##### Voir aussi

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

GuiObject.MouseLeave

Se déclenche lorsqu'un utilisateur déplace sa souris hors d'un élément GUI.

Se déclenche chaque fois qu'un utilisateur déplace sa souris alors qu'elle est à l'intérieur d'un
`Class.GuiObject`. C'est similaire à `Class.Mouse.Move`, qui
se déclenche peu importe si la souris de l'utilisateur est au-dessus d'un élément GUI.

Notez que cet événement se déclenche lorsque la position de la souris est mise à jour, donc il
se déclenchera plusieurs fois pendant le déplacement.

Les arguments `x` et `y` indiquent les coordonnées d'écran mises à jour de la
souris de l'utilisateur en pixels. Ceux-ci peuvent être utiles pour déterminer la position de la souris
sur le GUI, l'écran, et le delta par rapport à la position précédente de la souris
s'il est suivi dans une variable globale.

Le code ci-dessous démontre comment déterminer le décalage `Datatype.Vector2`
de la souris de l'utilisateur par rapport à un élément GUI.
`Class.GuiObject.AbsolutePosition|AbsolutePosition` est mesuré à l'intérieur de l'inset GUI de l'écran,
pendant que les arguments `x` et `y` de cet événement sont des coordonnées d'écran qui l'incluent,
ainsi l'exemple appelle `Class.GuiService:GetGuiInset()|GetGuiInset()` pour réconcilier les deux espaces
au lieu de supposer une taille d'inset fixe.

```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)
```
Notez que cet événement peut ne pas se déclencher exactement lorsque la souris de l'utilisateur entre ou
sort d'un élément GUI. Par conséquent, les arguments `x` et `y` peuvent ne pas correspondre
parfaitement aux coordonnées des bords du GUI.

##### Voir Aussi

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

GuiObject.MouseMoved

Se déclenche chaque fois qu'un utilisateur déplace sa souris alors qu'elle est à l'intérieur d'un élément GUI.

L'événement WheelBackward se déclenche lorsqu'un utilisateur fait défiler la molette de la souris vers l'arrière lorsque la souris est au-dessus d'un élément `Class.GuiObject`. C'est similaire à `Class.Mouse.WheelBackward`, qui se déclenche indépendamment de si la souris de l'utilisateur est au-dessus d'un élément GUI.

Cet événement se déclenche simplement comme un indicateur du mouvement arrière de la molette. Cela signifie que les arguments de coordonnées de souris `x` et `y` ne changent pas à la suite de cet événement. Ces coordonnées ne changent que lorsque la souris se déplace, ce qui peut être suivi par l'événement `Class.GuiObject.MouseMoved`.

##### Voir aussi

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

GuiObject.MouseWheelBackward

Se déclenche lorsqu'un utilisateur fait défiler la molette de la souris vers l'arrière lorsque la souris est au-dessus d'un élément GUI.

L'événement WheelForward se déclenche lorsqu'un utilisateur fait défiler la molette de la souris vers l'avant lorsque la souris est au-dessus d'un élément `Class.GuiObject`. C'est similaire à `Class.Mouse.WheelForward`, qui se déclenche indépendamment de si la souris de l'utilisateur est au-dessus d'un élément GUI.

Cet événement se déclenche simplement comme un indicateur du mouvement avant de la molette. Cela signifie que les coordonnées de souris **X** et **Y** ne changent pas à la suite de cet événement. Ces coordonnées ne changent que lorsque la souris se déplace, ce qui peut être suivi par l'événement `Class.GuiObject.MouseMoved`.

##### Voir aussi

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

GuiObject.MouseWheelForward

La coordonnée **Y** de la souris de l'utilisateur.

Se déclenche lorsqu'un utilisateur fait défiler la molette de la souris vers l'avant lorsque la souris est au-dessus d'un élément GUI.

L'exemple suivant imprime un message lorsque l'utilisateur sélectionne l'objet avec un
gamepad.

Pour que cela fonctionne comme prévu, il doit être placé dans un `LocalScript`
et un enfant de _gui_.


Cet événement se déclenche lorsque le sélecteur de gamepad commence à se concentrer sur le `Class.GuiObject`.

Si vous souhaitez vérifier quand le sélecteur de gamepad cesse de se concentrer sur l'élément GUI, vous pouvez utiliser l'événement `Class.GuiObject.SelectionLost`.

Lorsqu'un GUI gagne le focus de sélection, la valeur de la propriété `Class.GuiService.SelectedObject|SelectedObject` change également pour celui qui gagne la sélection. Pour déterminer quel GUI a gagné la sélection, vérifiez la valeur de cette propriété.

GuiObject.SelectionGained

Déclenché lorsque le GuiObject est mis au point avec le sélecteur de gamepad.

L'exemple suivant affiche un message lorsque l'élément perd son focus sur
une manette.

Pour que cela fonctionne comme prévu, il doit être placé dans un `LocalScript`
et être un enfant de _gui_.

Cet événement se déclenche lorsque le sélecteur de gamepad cesse de se concentrer sur le `Class.GuiObject`.

Si vous souhaitez vérifier quand le sélecteur de gamepad commence à se concentrer sur l'élément GUI, vous pouvez utiliser l'événement `Class.GuiObject.SelectionGained`.

Lorsqu'un GUI perd le focus de sélection, la valeur de la propriété `Class.GuiService.SelectionObject|SelectionObject` change soit en `nil` soit vers l'élément GUI qui gagne le focus de sélection. Pour déterminer quel GUI a gagné la sélection, ou si aucun GUI n'est sélectionné, vérifiez la valeur de cette propriété.

GuiObject.SelectionLost

Déclenché lorsque le sélecteur de gamepad cesse de se concentrer sur le GuiObject.

Cet exemple de code permet au joueur de manipuler la position à l'écran de certains
éléments UI, comme un `Frame`, en maintenant le doigt sur l'élément UI pendant un bref
moment. Ensuite, le joueur déplace son doigt et relâche. Pendant le geste,
le Frame est coloré en bleu avec un contour blanc.


Cet événement se déclenche après un bref moment lorsque le joueur maintient son doigt sur l'élément UI à l'aide d'un dispositif tactile. Il se déclenche avec un tableau de `Datatype.Vector2` qui décrit les positions d'écran relatives des doigts impliqués dans le geste. De plus, il se déclenche plusieurs fois : `Enum.UserInputState.Begin` après un bref délai, `Enum.UserInputState.Change` si le joueur déplace son doigt pendant le geste, et enfin `Enum.UserInputState.End`. Le délai dépend de la plateforme ; dans Studio, il est un peu plus long qu'une seconde.

GuiObject.TouchLongPress

touchPositions

Un tableau de `Datatype.Vector2` qui décrit les positions **relatives** des doigts impliqués dans le geste.

state

Un `Enum.UserInputState` qui décrit l'état du geste :

- Begin se déclenche une fois au début du geste (après le bref délai)
- Change se déclenche si le joueur déplace son doigt tout en maintenant enfoncé
- End se déclenche une fois à la fin du geste lorsqu'il relâche son doigt.

Déclenché lorsque le joueur commence, continue et arrête de maintenir longtemps l'élément UI.

Cet exemple de code est destiné à être placé dans un `LocalScript` à l'intérieur d'un
`Frame` qui se trouve à l'intérieur d'un `Frame` extérieur, ou d'un autre `GuiObject`. Il permet au
joueur de manipuler la position du cadre intérieur en déplaçant son doigt sur
le cadre extérieur.


Cet événement se déclenche lorsque le joueur déplace son doigt sur l'élément UI à l'aide d'un dispositif tactile. Il se déclenche peu avant que `Class.GuiObject.TouchSwipe` se déclenche, et ne se déclenche pas avec `Class.GuiObject.TouchTap`. Cet événement est utile pour permettre au joueur de manipuler la position des éléments UI à l'écran.

Cet événement se déclenche avec un tableau de `Datatype.Vector2` qui décrit les positions d'écran relatives des doigts impliqués dans le geste. De plus, il se déclenche plusieurs fois : `Enum.UserInputState.Begin` après un bref délai, `Enum.UserInputState.Change` lorsque le joueur déplace son doigt pendant le geste, et enfin avec `Enum.UserInputState.End`.

GuiObject.TouchPan

Un tableau Luau d'objets `Datatype.Vector2`, chacun indiquant la position de tous les doigts impliqués dans le geste.

totalTranslation

Indique à quel point le geste de panoramique a été éloigné de son point de départ.

velocity

Indique à quelle vitesse le geste est effectué dans chaque dimension.

Indique l'`Enum.UserInputState` du geste.

Déclenché lorsque le joueur déplace son doigt sur l'élément UI.

Cet exemple de code est destiné à un `LocalScript` à l'intérieur d'un `Frame` qui est
à l'intérieur d'un `Frame` extérieur, ou d'un autre `GuiObject`. Il permet au joueur de redimensionner
le cadre intérieur en effectuant un geste `Class.GuiObject.TouchPinch` sur le
cadre extérieur.


Cet événement se déclenche lorsque le joueur utilise deux doigts pour effectuer un geste de pincement ou d'étirement sur l'élément UI à l'aide d'un appareil tactile. Un **pincement** se produit lorsque deux doigts ou plus se rapprochent, et un **étirement** se produit lorsqu'ils s'éloignent. Cet événement se déclenche en conjonction avec `Class.GuiObject.TouchPan`. Cet événement est utile pour permettre au joueur de manipuler l'échelle (taille) des éléments UI à l'écran, et est le plus souvent utilisé pour des fonctionnalités de zoom.

Cet événement se déclenche avec une table de `Datatype.Vector2` qui décrit les positions relatives à l'écran des doigts impliqués dans le geste. De plus, il se déclenche plusieurs fois : `Enum.UserInputState.Begin` après un bref délai, `Enum.UserInputState.Change` lorsque le joueur déplace un doigt pendant le geste, et enfin avec `Enum.UserInputState.End`. Il convient de noter que l'échelle doit être utilisée **multiplicativement**.

GuiObject.TouchPinch

Un tableau Luau d'objets `Datatype.Vector2`, chacun indiquant la position de tous les doigts impliqués dans le geste de pincement.

scale

Un float qui indique la différence par rapport au début du geste de pincement.

Un float indiquant à quelle vitesse le geste de pincement se produit.

Déclenché lorsque le joueur effectue un geste de pincement ou de tirage avec deux doigts sur l'élément UI.

Cet exemple de code est destiné à un `LocalScript` à l'intérieur d'un `Frame` qui est
à l'intérieur d'un `Frame` extérieur, ou d'un autre `GuiObject`. Il permet au joueur de faire
rotater le cadre intérieur en effectuant un geste `Class.GuiObject.TouchRotate` sur le
cadre extérieur.


Cet événement se déclenche lorsque le joueur utilise deux doigts pour effectuer un geste de rotation sur l'élément UI à l'aide d'un appareil tactile. La rotation se produit lorsque l'angle de la ligne entre deux doigts change. Cet événement se déclenche en conjonction avec `Class.GuiObject.TouchPan`. Cet événement est utile pour permettre au joueur de manipuler la rotation des éléments UI à l'écran.

Cet événement se déclenche avec une table de `Datatype.Vector2` qui décrit les positions relatives à l'écran des doigts impliqués dans le geste. De plus, il se déclenche plusieurs fois : `Enum.UserInputState.Begin` après un bref délai, `Enum.UserInputState.Change` lorsque le joueur déplace un doigt pendant le geste, et enfin avec `Enum.UserInputState.End`.

GuiObject.TouchRotate

rotation

Un float indiquant combien la rotation a changé depuis le début du geste.

Un float qui indique à quelle vitesse le geste est effectué.

Se déclenche lorsque le joueur effectue un geste de rotation avec deux doigts sur l'élément UI.

Cet exemple de code fera rebondir un `Frame` (ou autre `GuiObject`) lorsqu'un geste de
balayage est effectué sur un appareil compatible tactile (ou l'émulateur de Studio).
Les balayages horizontaux changeront la teinte de la
`Class.GuiObject.BackgroundColor3`, tandis que les balayages verticaux changeront la
saturation.

Cet événement se déclenche lorsque le joueur effectue un geste de balayage sur l'élément UI à l'aide d'un appareil tactile. Il se déclenche avec la direction du geste (Haut, Bas, Gauche ou Droite) et le nombre de points de contact impliqués dans le geste. Les gestes de balayage sont souvent utilisés pour changer d'onglet dans les interfaces mobiles.

GuiObject.TouchSwipe

swipeDirection

Un `Enum.SwipeDirection` indiquant la direction du geste de balayage (Haut, Bas, Gauche ou Droite).

numberOfTouches

Le nombre de points de contact impliqués dans le geste (généralement 1).

Se déclenche lorsque le joueur effectue un geste de balayage sur l'élément UI.

Cet exemple de code permet d'activer/désactiver la `Class.GuiObject.BackgroundTransparency` d'un
élément UI, comme un `Frame`, lorsqu'il est touché sur un appareil à écran tactile.

Cet événement se déclenche lorsque le joueur effectue un geste de tapotement sur l'élément UI à l'aide d'un appareil tactile. Un tapotement est un contact rapide et unique sans mouvement impliqué (une pression plus longue déclencherait `Class.GuiObject.TouchLongPress`, et un mouvement pendant le contact déclencherait `Class.GuiObject.TouchPan` et/ou `Class.GuiObject.TouchSwipe`). Il se déclenche avec une table d'objets `Datatype.Vector2` qui décrivent les positions relatives des doigts impliqués dans le geste.

GuiObject.TouchTap

Un tableau de `Datatype.Vector2` qui décrit les **positions** relatives des doigts impliqués dans le geste.

Se déclenche lorsque le joueur effectue un geste de tapotement sur l'élément UI.

Cet exemple de code démontre une utilisation plus complexe de TweenPosition en
détectant quand l'animation se termine/est annulée en définissant une fonction de rappel. Il
imprime également si l'animation va jouer.


Déplace en douceur une interface utilisateur vers une nouvelle position `Datatype.UDim2` dans le temps spécifié en utilisant la `Enum.EasingDirection` et `Enum.EasingStyle` spécifiées.
Cette méthode génère une erreur si `easingStyle` est `Enum.EasingStyle.Bezier`
ou `Enum.EasingStyle.Spring`.

Cette fonction renverra si le tween va jouer. Il ne jouera pas si
un autre tween agit sur le `Class.GuiObject` et le paramètre override
est `false`.

Voir aussi `Class.GuiObject:TweenSize()` et
`Class.GuiObject:TweenSizeAndPosition()`.


GuiObject:TweenPosition

endPosition

easingDirection

La direction dans laquelle assouplir le GUI vers la _endPosition_.

easingStyle

Le style dans lequel assouplir le GUI vers la _endPosition_.

time

Combien de temps, en secondes, le tween doit prendre pour se terminer.

override

Si le tween va remplacer un tween en cours.

callback

Une fonction de rappel à exécuter lorsque le tween se termine.

Déplace en douceur un GUI vers un nouveau `Datatype.UDim2`.

Cet exemple de code démontre l'utilisation de la fonction `Class.GuiObject:TweenSize()`.
Il initie une animation sur la propriété `Class.GuiObject.Size` du parent
à `UDim2.new(0.5, 0, 0.5, 0)`, qui est la moitié de la taille du `GuiObject`
parent sur les deux axes.

De plus, il démontre comment le paramètre de rappel peut être utilisé pour détecter
quand l'animation s'arrête (qu'elle ait été annulée par une autre animation ou complétée).


Redimensionne en douceur un `Class.GuiObject` à un nouveau `Datatype.UDim2` dans le
temps spécifié en utilisant la `Enum.EasingDirection` et
`Enum.EasingStyle` spécifiées. Cette méthode génère une erreur si `easingStyle` est
`Enum.EasingStyle.Bezier` ou `Enum.EasingStyle.Spring`.

Cette fonction renverra si le tween va jouer. Normalement, cela renverra
toujours `true`, mais cela renverra `false` si un autre tween est
actif et que l'override est défini sur `false`.

Voir aussi `Class.GuiObject:TweenSize()` et
`Class.GuiObject:TweenSizeAndPosition()`.


GuiObject:TweenSize

endSize

La taille à laquelle le GUI doit redimensionner.

La direction dans laquelle assouplir le GUI vers la _endSize_.

Le style dans lequel assouplir le GUI vers la _endSize_.

Redimensionne en douceur un `Class.GuiObject` à un nouveau `Datatype.UDim2`.

L'exemple ci-dessous animerait un `Class.Frame` vers le coin supérieur gauche de la taille du parent
et le redimensionnerait à 0.


Redimensionne et déplace en douceur une interface utilisateur vers une nouvelle taille `Datatype.UDim2` et
position dans le temps spécifié en utilisant la `Enum.EasingDirection`
et `Enum.EasingStyle` spécifiées. Cette méthode génère une erreur si `easingStyle` est
`Enum.EasingStyle.Bezier` ou `Enum.EasingStyle.Spring`.

Cette fonction renverra si le tween va jouer. Normalement, cela renverra
toujours `true`, mais cela renverra `false` si un autre tween est
actif et que l'override est défini sur `false`.

Voir aussi `Class.GuiObject:TweenSize()` et
`Class.GuiObject:TweenSizeAndPosition()`.


GuiObject:TweenSizeAndPosition

La direction dans laquelle assouplir le GUI vers la _endSize_ et _endPosition_.

Le style dans lequel assouplir le GUI vers la _endSize_ et _endPosition_.

Déplace en douceur un GUI vers une nouvelle taille et position.

GuiObject

Cet exemple de code démontre l'utilisation de la propriété Active comme un debounce
pour l'événement Activated.

Cette propriété détermine si le `Class.GuiObject` va recevoir des entrées dans l'espace 3D, comme les modèles sous-jacents avec une classe `Class.ClickDetector` comme `Class.DragDetector`.

Pour les objets `Class.GuiButton` (`Class.ImageButton` et `Class.TextButton`), cette propriété détermine si `Class.GuiButton.Activated|Activated` se déclenche (`Class.GuiButton.AutoButtonColor|AutoButtonColor` fonctionnera également pour ceux-ci). Les événements `Class.GuiObject.InputBegan|InputBegan`, `Class.GuiObject.InputChanged|InputChanged`, et `Class.GuiObject.InputEnded|InputEnded` fonctionnent normalement peu importe la valeur de cette propriété.

GuiObject.Active

Détermine si cet élément UI reçoit les entrées.

Cet exemple de code déplace un élément UI vers différents côtés de l'élément parent.
Il commence en haut à gauche et se termine en bas à droite. Collez-le dans un
LocalScript dans un Frame, au sein d'un ScreenGui.


Cette propriété détermine le point d'origine d'un `Class.GuiObject`, par rapport à sa taille absolue. Le point d'origine détermine d'où l'élément est positionné (via `Class.GuiObject.Position`) et à partir de quel point la taille rendue `Class.GuiObject.Size` s'étend.

Voir [ici](/ui/position-and-size#anchorpoint) pour des diagrammes illustrés et des détails.

GuiObject.AnchorPoint

Détermine le point d'origine d'un `Class.GuiObject`, par rapport à sa taille absolue.

Le script suivant crée un cadre parent de taille automatique avec
a`UIListLayout`, puis il insère plusieurs objets `TextLabel`
de taille automatique. Notez comment le `UIListLayout` parent se redimensionne automatiquement pour s'adapter à son
contenu enfant et comment les étiquettes se redimensionnent automatiquement pour s'adapter à leur contenu textuel.
Ce script peut être parenté à un `ScreenGui`.


Cette propriété est utilisée pour dimensionner automatiquement les objets UI parents en fonction de la taille de ses descendants. Vous pouvez utiliser cette propriété pour ajouter dynamiquement du texte et d'autres contenus à un objet UI à l'édition ou à l'exécution, et la taille s'ajustera pour s'adapter à ce contenu.

Lorsque `Class.GuiObject.AutomaticSize|AutomaticSize` est défini sur une valeur `Enum.AutomaticSize` autre que `Enum.AutomaticSize|None`, cet objet UI peut redimensionner en fonction de son contenu enfant.

Pour plus d'informations sur la façon d'utiliser cette propriété et son fonctionnement, veuillez voir [ici](/ui/size-modifiers#automatic-sizing).

GuiObject.AutomaticSize

Détermine si le redimensionnement se produit en fonction du contenu enfant.

Détermine la couleur de l'arrière-plan du `Class.GuiObject`.

GuiObject.BackgroundColor

Cet exemple de code fait en sorte qu'un cadre parent parcourt toutes les couleurs de l'
arc-en-ciel en utilisant Color3.fromHSV.


Cette propriété détermine la couleur d'arrière-plan d'un `Class.GuiObject` (la couleur de remplissage). Si votre élément contient du texte, tel qu'un `Class.TextBox`, `Class.TextButton`, ou `Class.TextLabel`, assurez-vous que la couleur de votre arrière-plan contraste avec la couleur du texte.

Une autre propriété qui détermine les propriétés visuelles de l'arrière-plan est `Class.GuiObject.BackgroundTransparency`; si cela est défini sur `1`, ni l'arrière-plan ni la bordure ne seront rendus.

Voir aussi `Class.GuiObject.BorderColor3|BorderColor3`.

GuiObject.BackgroundColor3

Détermine la couleur d'arrière-plan du `Class.GuiObject`.

Cette propriété détermine la transparence de l'arrière-plan et de la bordure du `Class.GuiObject`. Cependant, elle ne détermine pas la transparence du texte si le GUI est un `Class.TextBox`, `Class.TextButton`, ou `Class.TextLabel`; la transparence du texte est déterminée par `Class.TextBox.TextTransparency`, `Class.TextButton.TextTransparency`, et `Class.TextLabel.TextTransparency` respectivement.

Si cette propriété est définie sur `1`, ni l'arrière-plan ni la bordure ne seront rendus et l'arrière-plan du GUI sera complètement transparent.

GuiObject.BackgroundTransparency

Détermine la transparence de l'arrière-plan et de la bordure du `Class.GuiObject`.

Détermine la couleur de la bordure du `Class.GuiObject`.

GuiObject.BorderColor

Cet exemple de code fait en sorte que la bordure d'un GuiObject parent soit surlignée lorsque l'utilisateur survole l'élément avec sa souris.


Détermine la couleur de la bordure rectangulaire du `Class.GuiObject` (également connue sous le nom de couleur de contour). Cela est séparé de la couleur d'arrière-plan de l'objet `Class.GuiObject.BackgroundColor3`. Vous ne pourrez pas voir la bordure de l'objet si sa propriété `Class.GuiObject.BorderSizePixel` est définie sur `0`.

Notez que le composant `Class.UIStroke` permet des effets de bordure plus avancés.

GuiObject.BorderColor3

Cette propriété détermine de quelle manière la bordure du `Class.GuiObject` est disposée par rapport à ses dimensions en utilisant l'énumération du même nom, `Enum.BorderMode`.

Notez que `Class.UIStroke` peut remplacer cette propriété et permettre des effets de bordure plus avancés.

GuiObject.BorderMode

Détermine de quelle manière la bordure du `Class.GuiObject` est disposée par rapport à ses dimensions.

Cette propriété détermine la largeur de la bordure du `Class.GuiObject`, en pixels. La définition de cela sur 0 désactive complètement la bordure.

Notez que `Class.UIStroke` peut remplacer cette propriété et permettre des effets de bordure plus avancés.

GuiObject.BorderSizePixel

Détermine la largeur en pixels de la bordure du `Class.GuiObject`.

Cette propriété détermine si le `Class.GuiObject` va couper (rendre invisible) toute portion des éléments GUI descendants qui seraient autrement rendus en dehors des limites du rectangle.

#### Comportement de rotation

Lorsque `Class.StarterGui.ClipsDescendantsSupportsRotation` est activé, le découpage fonctionne correctement pour les formes tournées. Cependant, le découpage **par** des formes tournées (lorsque le parent de découpage lui-même est tourné) ou par des coins arrondis (`Class.UICorner`) n'est pas pris en charge.

Lorsque `Class.StarterGui.ClipsDescendantsSupportsRotation` n'est **pas** activé et que ce `Class.GuiObject` ou tout ancêtre `Class.GuiObject` a une `Class.GuiObject.Rotation|Rotation` **non nulle**, cette propriété est **ignorée** et les éléments GUI descendants seront rendus indépendamment de la valeur de cette propriété.

GuiObject.ClipsDescendants

Détermine si les descendants `Class.GuiObject|GuiObjects` en dehors des limites d'un élément GUI parent doivent être rendus.

Cela indique si un `Class.GuiObject` (et ses descendants) peut être déplacé sur l'écran.

GuiObject.Draggable

Détermine si un `Class.GuiObject` (et ses descendants) peut être déplacé sur l'écran.

Lorsque le doigt du joueur est tapé et maintenu sur le `Class.GuiObject`, l'état `Class.GuiObject.GuiState|GuiState` du `Class.GuiObject` sera défini sur `Enum.GuiState.Press|Press`. De même, lorsque le doigt du joueur est relâché du `Class.GuiObject`, l'état `Class.GuiObject.GuiState|GuiState` du `Class.GuiObject` sera défini sur `Enum.GuiState.Idle|Idle`, et lorsque `Class.GuiObject.Interactable|Interactable` est désactivé sur le `Class.GuiObject`, l'état `Class.GuiState` du `Class.GuiObject` sera défini sur `Enum.GuiState.NonInteractable|NonInteractable`.

GuiObject.GuiState

Détermine si la souris du joueur est activement pressée sur le `Class.GuiObject` ou non.

Contrôle si, et dans quelle mesure, le `Class.GuiObject` reçoit les entrées qui se produisent au-dessus de lui, en utilisant `Enum.InputSink`. Recevoir des entrées empêche celles-ci de passer à travers les objets derrière l'élément, y compris les objets 3D dans le monde tels que ceux avec un `Class.ClickDetector` ou `Class.DragDetector`. Par défaut, cela est défini sur `Enum.InputSink.None`, sauf pour les objets `Class.GuiButton` (`Class.ImageButton` et `Class.TextButton`), où cela est défini sur `Enum.InputSink.Activate`.

- `Enum.InputSink.None` — l'objet ne reçoit pas d'entrées par lui-même.
- `Enum.InputSink.Activate` — l'objet reçoit l'entrée de pression/release de bouton de souris et de toucher utilisée pour l'activer, mais laisse passer d'autres entrées (comme le mouvement de la souris).
- `Enum.InputSink.All` — l'objet reçoit toutes les entrées qui se produisent au-dessus de lui.

Cette propriété est un successeur plus granulaire de la propriété booléenne `Class.GuiObject.Active|Active`, qui ne peut recevoir toutes les entrées ou aucune. Les événements `Class.GuiObject.InputBegan|InputBegan`, `Class.GuiObject.InputChanged|InputChanged`, et `Class.GuiObject.InputEnded|InputEnded` se déclenchent indépendamment de la valeur de cette propriété.

GuiObject.InputSink

Contrôle si, et comment, le `Class.GuiObject` reçoit les entrées qui se produisent au-dessus de lui.

Détermine si le `Class.GuiButton` peut être interagi avec ou non, ou si l'état `Enum.GuiState|GuiState` du `Class.GuiObject` change ou non.

Sur un `Class.GuiButton`:

- Lorsque le paramètre `Class.GuiObject.Interactable|Interactable` sur le `Class.GuiButton` est défini sur `false`, le `Class.GuiButton` ne pourra plus être pressé ou cliqué, et l'état `Class.GuiObject.GuiState|GuiState` sera constamment défini sur `Enum.GuiState.NonInteractable|NonInteractable`.
- Lorsque le paramètre `Class.GuiObject.Interactable|Interactable` sur le `Class.GuiButton` est défini sur `true`, le `Class.GuiButton` se comportera normalement à nouveau et l'état `Class.GuiObject.GuiState|GuiState` se comportera normalement.

Sur un `Class.GuiObject`:

- Lorsque le paramètre `Class.GuiObject.Interactable|Interactable` sur le `Class.GuiButton` est défini sur `false`, l'état `Class.GuiObject.GuiState|GuiState` sera constamment défini sur `Enum.GuiState.NonInteractable|NonInteractable`.
- Lorsque le paramètre `Class.GuiObject.Interactable|Interactable` sur le `Class.GuiButton` est défini sur `true`, l'état `Class.GuiObject.GuiState|GuiState` se comportera normalement à nouveau.

GuiObject.Interactable

Détermine si le `Class.GuiButton` peut être interagi avec ou non, ou si l'état `Enum.GuiState|GuiState` du `Class.GuiObject` change ou non.

Cette propriété contrôle l'ordre de tri du `Class.GuiObject` lors de l'utilisation d'un `Class.UIGridStyleLayout` (tel que `Class.UIListLayout` ou `Class.UIPageLayout`) avec `Class.UIGridStyleLayout.SortOrder|SortOrder` défini sur `Enum.SortOrder.LayoutOrder`. Elle n'a aucune fonctionnalité si l'objet n'a pas de structure de mise en page UI sœur.

`Class.GuiObject|GuiObjects` sont triés par ordre croissant où les valeurs plus basses ont la priorité sur les valeurs plus élevées. Les objets avec des valeurs égales retombent dans l'ordre dans lequel ils ont été ajoutés.

Si vous n'êtes pas sûr de devoir ajouter un élément entre deux éléments existants à l'avenir, il est bon d'utiliser des multiples de `100` (`0`, `100`, `200`, etc.). Cela garantit un grand écart de valeurs d'ordre de mise en page que vous pouvez utiliser pour des éléments ordonnés entre d'autres éléments.

Voir aussi `Class.GuiObject.ZIndex|ZIndex` qui détermine l'ordre de **rendu** de l'objet au lieu de l'ordre de tri.

GuiObject.LayoutOrder

Contrôle l'ordre de tri du `Class.GuiObject` lorsqu'il est utilisé avec un `Class.UIGridStyleLayout`.

Cet exemple démontre comment activer la navigation par manette à travers une grille d'éléments
`GuiObject|GUI` sans avoir à connecter manuellement les propriétés
`Class.GuiObject.NextSelectionUp`, `Class.GuiObject.NextSelectionDown`, et
`GuiObject|NextSelectionRight`, et `Class.GuiObject.NextSelectionLeft`
pour chaque élément de la grille.

Notez que cet exemple de code suppose que votre `UIGridLayout` est trié par
`Class.UIGridLayout.SortOrder|name`, où les éléments sont nommés dans un ordre numérique successif.

Le code s'appuie sur cela pour définir les propriétés NextSelection pour tous
`GuiObjects` au même niveau que le UIGridLayout. Dans notre exemple, l'
UIGridLayoutObject et les éléments GUI dans la grille sont tous des enfants d'un
`Frame` nommé _"Container"_. Le code
`Class.Instance:GetChildren()|obtient les enfants` de _"Container"_ et boucle
à travers chaque enfant. Les enfants qui ne sont pas des GuiObjects sont ignorés. Pour chaque élément GUI,
le code tente d'assigner les propriétés NextSelection en utilisant la
logique suivante :

1. En commençant par 1, le nom de tous les éléments GUI correspond à leur position dans la
   grille
2. Gauche : L'élément à gauche sera toujours numéroté 1 de moins que l'élément actuel
3. Droite : L'élément à droite sera toujours numéroté 1 de plus que l'élément actuel
4. Haut : L'élément au-dessus (haut) sera toujours le nombre de GUIs dans une rangée 1 de moins que
   l'élément actuel
5. Bas : L'élément en dessous (bas) sera toujours le nombre de GUIs dans une rangée plus
   que l'élément actuel Cette logique permet également aux éléments GUI aux
   débuts et fins de rangées (à l'exception du premier et du dernier élément) de se
   replier sur les rangées suivantes et précédentes. Si un élément n'existe pas à gauche,
   droite, en haut ou en bas, le NextSelection restera nil et déplacer le
   sélecteur de manette dans la direction ne changera pas le GUI sélectionné.

Cet exemple contient également du code pour tester la grille en utilisant les touches fléchées (Haut,
Bas, Gauche, Droite) de votre clavier au lieu d'une manette, juste au cas où vous
n'auriez pas de manette pour tester. Cette partie du code sélectionne initialement l'
élement nommé _"1"_ en l'assignant à la propriété `Class.GuiService.SelectedObject`.


Cette propriété définit le `Class.GuiObject` sélectionné lorsque l'utilisateur déplace le sélecteur de [gamepad](/input/gamepad) vers le bas. Si cette propriété est vide, déplacer le gamepad vers le bas ne changera pas le GUI sélectionné.

Déplacer le sélecteur de gamepad vers le bas définit le `Class.GuiService.SelectedObject` sur cet objet à moins que le GUI ne soit pas `Class.GuiObject.Selectable|Selectable`. Notez que cette propriété peut être définie sur un élément GUI même s'il n'est pas `Class.GuiObject.Selectable|Selectable`, donc vous devez vous assurer que la valeur de la propriété sélectionnable d'un GUI correspond à votre comportement attendu.

Voir aussi `Class.GuiObject.NextSelectionUp|NextSelectionUp`, `Class.GuiObject.NextSelectionLeft|NextSelectionLeft`, et `Class.GuiObject.NextSelectionRight|NextSelectionRight`.

GuiObject.NextSelectionDown

Définit le `Class.GuiObject` qui sera sélectionné lorsque le sélecteur de gamepad est déplacé vers le bas.

Cette propriété définit le `Class.GuiObject` sélectionné lorsque l'utilisateur déplace le sélecteur de [gamepad](/input/gamepad) vers la gauche. Si cette propriété est vide, déplacer le gamepad vers la gauche ne changera pas le GUI sélectionné.

Déplacer le sélecteur de gamepad vers la gauche définit le `Class.GuiService.SelectedObject` sur cet objet à moins que le GUI ne soit pas `Class.GuiObject.Selectable|Selectable`. Notez que cette propriété peut être définie sur un élément GUI même s'il n'est pas `Class.GuiObject.Selectable|Selectable`, donc vous devez vous assurer que la valeur de la propriété sélectionnable d'un GUI correspond à votre comportement attendu.

Voir aussi `Class.GuiObject.NextSelectionUp|NextSelectionUp`, `Class.GuiObject.NextSelectionDown|NextSelectionDown`, et `Class.GuiObject.NextSelectionRight|NextSelectionRight`.

GuiObject.NextSelectionLeft

Définit le `Class.GuiObject` qui sera sélectionné lorsque le sélecteur de gamepad est déplacé vers la gauche.

Cette propriété définit le `Class.GuiObject` sélectionné lorsque l'utilisateur déplace le sélecteur de [gamepad](/input/gamepad) vers la droite. Si cette propriété est vide, déplacer le gamepad vers la droite ne changera pas le GUI sélectionné.

Déplacer le sélecteur de gamepad vers la droite définit le `Class.GuiService.SelectedObject` sur cet objet à moins que le GUI ne soit pas `Class.GuiObject.Selectable|Selectable`. Notez que cette propriété peut être définie sur un élément GUI même s'il n'est pas `Class.GuiObject.Selectable|Selectable`, donc vous devez vous assurer que la valeur de la propriété sélectionnable d'un GUI correspond à votre comportement attendu.

Voir aussi `Class.GuiObject.NextSelectionUp|NextSelectionUp`, `Class.GuiObject.NextSelectionDown|NextSelectionDown`, et `Class.GuiObject.NextSelectionLeft|NextSelectionLeft`.

GuiObject.NextSelectionRight

Définit le `Class.GuiObject` qui sera sélectionné lorsque le sélecteur de gamepad est déplacé vers la droite.

Une classe abstraite pour tous les objets d'interface utilisateur 2D.

/reference/engine/classes/TextChannelWindow.yaml

Résumé