Un `Class.VideoDisplay` est un objet GUI qui affiche le contenu vidéo d'un
`Class.VideoPlayer` connecté via un `Class.Wire`. Il fonctionne de manière similaire à un
`Class.ImageLabel`, mais est conçu pour la lecture vidéo.

Se déclenche après qu'un `Class.Wire` est devenu connecté ou déconnecté, et que
ce `Class.Wire` est maintenant ou était précédemment connecté à un pin sur le
`Class.VideoDisplay` et à une autre instance câblable.

VideoDisplay.WiringChanged

connected

Si l'instance a été connectée ou déconnectée.

Le pin sur le `Class.VideoDisplay` que le `Class.Wire` cible.

wire

Le `Class.Wire` entre le `Class.VideoDisplay` et l'autre
instance.

instance

L'autre instance qui est ou était connectée via le `Class.Wire`.

Se déclenche lorsqu'une autre instance est connectée ou déconnectée du
`Class.VideoDisplay` via un `Class.Wire`.

Renvoie un tableau de `Class.Wire|Wires` qui sont connectés au pin spécifié. `Class.VideoDisplay` a un pin "Input".

VideoDisplay:GetConnectedWires

Une broche d'entrée ou de sortie sur cette instance

Renvoie un tableau de `Class.Wire|Wires` qui sont connectés au pin spécifié.

Obtient la liste des broches que `Class.Wire` peut utiliser dans `Class.Wire.TargetName`
pour se connecter à cette instance via sa propriété `Class.Wire.TargetInstance`.

Pour `Class.VideoDisplay`, ceci est uniquement `Input`.

VideoDisplay:GetInputPins

Un tableau de chaînes représentant des noms de broches valides.

Obtient la liste des broches que `Class.Wire` peut utiliser dans `Class.Wire.TargetName`
pour se connecter à cette instance via sa propriété `Class.Wire.TargetInstance`.

Obtient la liste des broches que `Class.Wire` peut utiliser dans `Class.Wire.SourceName`
pour se connecter à cette instance via sa propriété `Class.Wire.SourceInstance`.

Pour `Class.VideoDisplay`, il n'y en a aucune.

VideoDisplay:GetOutputPins

Obtient la liste des broches que `Class.Wire` peut utiliser dans `Class.Wire.SourceName`
pour se connecter à cette instance via sa propriété `Class.Wire.SourceInstance`.

VideoDisplay

Détermine l'apparence de la vidéo lorsqu'elle est mise à l'échelle. Par défaut, la vidéo
adoucit le texturage lorsqu'elle est affichée sur un écran plus grand ou plus petit que
sa taille dans la mémoire de texture. Lorsqu'il est réglé sur
`Enum.ResamplerMode.Pixelated|Enum.ResamplerMode.Pixelated`, la vidéo
préserve les bords nets des pixels.

VideoDisplay.ResampleMode

Sélectionne le mode de rééchantillonnage de texture pour le `Class.VideoDisplay`.

Détermine comment une texture vidéo est rendue lorsque le rapport d'aspect de l'élément UI
diffère de celui de la vidéo source.

Par défaut, cette propriété est `Enum.ScaleType.Stretch`, ce qui va simplement
étirer/compacter les dimensions de la texture vidéo pour qu'elle s'adapte exactement à l'espace de l'élément UI.

VideoDisplay.ScaleType

Détermine comment une vidéo sera mise à l'échelle si elle est affichée dans un élément UI dont
le rapport d'aspect diffère de celui de la vidéo source.

VideoDisplay.TileSize

Détermine comment une vidéo est colorisée. Lorsqu'il est réglé sur blanc, aucune colorisation
n'a lieu. Cette propriété est utile pour réutiliser des ressources vidéo.

VideoDisplay.VideoColor3

Détermine comment une vidéo rendue sera colorisée.

Permet l'affichage partiel d'une vidéo en conjonction avec
`Class.VideoDisplay.VideoRectSize|VideoRectSize`. Cette propriété détermine
le décalage en pixels (depuis le coin supérieur gauche) de la zone vidéo à afficher.

VideoDisplay.VideoRectOffset

Le décalage en pixels de la sous-zone d'une vidéo à afficher.

Permet l'affichage partiel d'une vidéo en conjonction avec
`Class.VideoDisplay.VideoRectOffset|VideoRectOffset`. Cette propriété
détermine la taille en pixels de la zone vidéo à afficher. Si l'une
ou l'autre dimension est réglée sur `0`, la vidéo entière est affichée à la place.

VideoDisplay.VideoRectSize

Détermine la taille en pixels de la sous-zone d'une vidéo à afficher.

Détermine l'alpha de la texture vidéo rendue d'un élément UI. Une valeur de
`0` est complètement opaque, et une valeur de `1` est complètement transparente
(invisible).

VideoDisplay.VideoTransparency

Détermine la transparence de la vidéo rendue.

Un objet GUI qui affiche le contenu vidéo d'un `Class.VideoPlayer` connecté.

`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 liées à l'affichage d'un objet d'interface graphique (GUI) tel que `Class.GuiObject.Size|Size` et `Class.GuiObject.Position|Position`. Elle a également certaines propriétés en lecture seule utiles comme `Class.GuiObject.AbsolutePosition|AbsolutePosition`, `Class.GuiObject.AbsoluteSize|AbsoluteSize`, et `Class.GuiObject.AbsoluteRotation|AbsoluteRotation`.

Pour manipuler la mise en page 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 fondamentales 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 tout objet GUI en utilisant `Class.GuiObject.InputBegan|InputBegan` et `Class.GuiObject.InputEnded|InputEnded`, seuls `Class.ImageButton` et `Class.TextButton` disposent d'é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 lorsque le 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 l'opération de glissement.

Déclenché lorsque le 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 de l'endroit où le joueur a arrêté de glisser le GUI. Par exemple, si le
joueur arrêtait de glisser l'objet à 189, 180, cela imprimerait : Le
joueur a arrêté de glisser le GuiObject à (189, 180)

Cet événement se déclenche lorsque le 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, relative au coin supérieur gauche de l'écran.

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

Déclenché lorsque le 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, il doit être placé dans un `LocalScript`
et un enfant de _gui_.

Cet événement se déclenche lorsqu'un utilisateur interagit 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, quelle que soit 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 de l'utilisateur
comme 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 son mode d'interaction 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, quelle que soit l'état du jeu.

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

GuiObject.InputChanged

Déclenché lorsqu'un utilisateur change son mode d'interaction 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 des entrées
utilisateur de InputEnded en fonction de leur type.

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

L'événement InputEnded se déclenche lorsque l'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, quelle que soit 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 de l'utilisateur
comme 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 la position 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` transmis 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 au moment où 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 lorsque 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, relative au coin supérieur gauche de l'écran.

La coordonnée **Y** de la souris à l'écran en pixels, relative 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 lorsque l'utilisateur déplace sa souris hors d'un élément `Class.GuiObject`.

Veuillez ne pas vous fier aux arguments `x` et `y` transmis 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 au moment où 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 élément `Class.GuiObject`. C'est similaire à `Class.Mouse.Move`, qui se déclenche indépendamment de si la souris de l'utilisateur est sur un élément GUI.

Notez que cet événement se déclenche lorsque la position de la souris est mise à jour, il se déclenchera donc à plusieurs reprises lors du mouvement.

Les arguments `x` et `y` indiquent les coordonnées d'écran mises à jour de la souris de l'utilisateur en pixels. Cela peut être utile 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 si elle est suivie dans une variable globale.

Le code ci-dessous montre comment déterminer l'offset `Datatype.Vector2` de la souris de l'utilisateur par rapport à un élément 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)
```
Notez que cet événement peut ne pas se déclencher exactement au moment où 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 sa souris en arrière lorsqu'elle est sur 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 sur un élément GUI.

Cet événement se déclenche simplement comme un indicateur du mouvement en arrière de la roue. 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 sa souris en arrière alors que la souris est sur un élément GUI.

L'événement WheelForward se déclenche lorsqu'un utilisateur fait défiler sa souris en avant lorsqu'elle est sur 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 sur un élément GUI.

Cet événement se déclenche simplement comme un indicateur du mouvement vers l'avant de la roue. 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 sa souris en avant alors que la souris est sur un élément GUI.

L'exemple suivant affiche un message lorsque l'utilisateur sélectionne l'objet avec un
manette.

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 la manette de jeu commence à se concentrer sur le `Class.GuiObject`.

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

Lorsque un GUI acquiert la concentration de sélection, la valeur de la propriété `Class.GuiService.SelectedObject|SelectedObject` change également vers celui qui acquiert la sélection. Pour déterminer quel GUI a acquis 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 la manette de jeu.

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 la manette de jeu cesse de se concentrer sur le `Class.GuiObject`.

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

Lorsque un GUI perd la concentration de sélection, la valeur de la propriété `Class.GuiService.SelectionObject|SelectionObject` change soit vers `nil` soit vers l'élément GUI qui acquiert la concentration de sélection. Pour déterminer quel GUI a acquis 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 la manette de jeu 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 l'élément UI pendant un court
instant. 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 de l'interface utilisateur en utilisant un appareil tactile. Il se déclenche avec une table 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 court 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 appuyant
- End se déclenche une fois à la fin du geste lorsque le joueur relâche son doigt.

Déclenché lorsque le joueur commence, continue et arrête de faire un appui long sur l'élément de l'UI.

Cet exemple de code est destiné à être placé dans 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 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 de l'interface utilisateur
en utilisant un appareil tactile. Il se déclenche peu avant
`Class.GuiObject.TouchSwipe`, 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 de l'interface utilisateur à l'écran.

Cet événement se déclenche avec une table 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
court 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 progressé par rapport à 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` intérieur 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 de `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 de tirage
sur l'élément de l'interface utilisateur en utilisant un appareil tactile. Un **pincement**
se produit lorsque deux doigts ou plus se rapprochent, et un **tirage**
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 de l'interface utilisateur à l'écran, et est le plus
souvent utilisé pour les fonctions de zoom.

Cet événement se déclenche avec une table 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
court délai, `Enum.UserInputState.Change` lorsque le joueur déplace un doigt
durant 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 flottant qui indique la différence par rapport au début du geste de pincement.

Un flottant indiquant à quelle vitesse le geste de pincement s'effectue.

Déclenché lorsque le joueur effectue un geste de pincement ou de tirage avec deux doigts sur l'élément de l'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 pivoter 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 pincement ou de tirage
sur l'élément de l'interface utilisateur en utilisant 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 de l'interface utilisateur à l'écran.

Cet événement se déclenche avec une table 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
court délai, `Enum.UserInputState.Change` lorsque le joueur déplace un doigt
durant le geste, et enfin avec `Enum.UserInputState.End`.

GuiObject.TouchRotate

rotation

Un flottant indiquant à quel point la rotation a progressé depuis le début du geste.

Un flottant 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 glissement sur l'élément de l'interface
utilisateur en utilisant 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 glissement sont souvent utilisés pour changer d'onglets dans les
iU mobiles.

GuiObject.TouchSwipe

swipeDirection

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

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 de l'interface
utilisateur en utilisant un appareil tactile. Un tapotement est un contact unique rapide sans aucun
mouvement impliqué (une pression plus longue déclencherait
`Class.GuiObject.TouchLongPress`, et se déplacer pendant le contact déclencherait
`Class.GuiObject.TouchPan` et/ou `Class.GuiObject.TouchSwipe`). Cela 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 tap sur l'élément UI.

Cet échantillon de code démontre une utilisation plus impliquée de TweenPosition en
détectant quand le tween est terminé/annulé en définissant une fonction de rappel. Il
imprime également si le tween va jouer.

Déplace en douceur un GUI vers une nouvelle position `Datatype.UDim2` dans le temps spécifié en utilisant la direction et le style d'adoucissement spécifiés `Enum.EasingDirection` et `Enum.EasingStyle`.

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

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

GuiObject:TweenPosition

endPosition

easingDirection

La direction dans laquelle adoucir le GUI vers le _endPosition_.

easingStyle

Le style dans lequel adoucir le GUI vers le _endPosition_.

time

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

override

Que le tween va remplacer un tween en cours.

callback

Une fonction de rappel à exécuter lorsque le tween est terminé.

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 pour passer à `UDim2.new(0.5, 0, 0.5, 0)`, ce qui représente la moitié de la
taille d'un `GuiObject` du 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 qu'elle soit terminée).

Redimensionne en douceur un `Class.GuiObject` à un nouveau `Datatype.UDim2` dans le temps spécifié en utilisant la direction et le style d'adoucissement spécifiés `Enum.EasingDirection` et `Enum.EasingStyle`.

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 override est défini sur `false`.

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

GuiObject:TweenSize

endSize

La taille que le GUI devrait redimensionner.

La direction dans laquelle adoucir le GUI vers le _endSize_.

Le style dans lequel adoucir le GUI vers le _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 un GUI vers une nouvelle taille `Datatype.UDim2` et position dans le temps spécifié en utilisant la direction et le style d'adoucissement spécifiés `Enum.EasingDirection` et `Enum.EasingStyle`.

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

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

GuiObject:TweenSizeAndPosition

La direction dans laquelle adoucir le GUI vers le _endSize_ et _endPosition_.

Le style dans lequel adoucir le GUI vers le _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` absorbe l'entrée dans l'espace 3D, comme des 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` est déclenché (`Class.GuiButton.AutoButtonColor|AutoButtonColor` fonctionnera toujours pour ceux-ci également). Les événements `Class.GuiObject.InputBegan|InputBegan`, `Class.GuiObject.InputChanged|InputChanged`, et `Class.GuiObject.InputEnded|InputEnded` fonctionnent normalement, quelle que soit la valeur de cette propriété.

GuiObject.Active

Détermine si cet élément UI absorbe l'entrée.

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 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 duquel la `Class.GuiObject.Size` rendue 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 à taille automatique avec
un `UIListLayout`, puis il insère plusieurs objets `TextLabel` à taille automatique.
Notez comment le `UIListLayout` parent redimensionne automatiquement pour s'adapter à
son contenu enfant et les étiquettes redimensionnent automatiquement pour s'adapter à leur contenu textuel.
Ce script peut être parenté à un `ScreenGui`.

Cette propriété est utilisée pour redimensionner automatiquement les objets UI parents en fonction de la taille de leurs descendants. Vous pouvez utiliser cette propriété pour ajouter dynamiquement du texte et d'autres contenus à un objet UI au moment de l'édition ou d'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 sur son fonctionnement, veuillez voir [ici](/ui/size-modifiers#automatic-sizing).

GuiObject.AutomaticSize

Détermine si le redimensionnement se fait 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 boucle à travers toutes les couleurs de l'
arc-en-ciel en utilisant Color3.fromHSV.

Cette propriété détermine la couleur de l'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 celle-ci est définie 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 mise en surbrillance 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 trait). 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.

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

/reference/engine/classes/VideoDisplay.yaml