`InputActionLabel` est un `Class.GuiObject` glisser-déposer qui montre automatiquement
la touche ou l'icône appropriée pour un `Class.InputAction` en fonction de
l'appareil d'entrée actuel du joueur (clavier/souris, manette, tactile, VR). Lorsque le
joueur change d'appareil ou que le raccourci est réaffecté, l'étiquette se met à jour instantanément
sans script.

Le rendu de l'`InputActionLabel` dépend du `Class.InputAction` (lié
via `Class.InputActionLabel.InputAction`) et des enfants `Class.InputBinding|InputBindings` de cette action. Au fur et à mesure que l'étiquette détermine quoi afficher, elle
suit cet ordre :

1. **Images personnalisées** — Si les enfants `Class.InputBinding|InputBindings` ont leur
   propriété `Class.InputBinding.DisplayImage|DisplayImage` définie, l'étiquette
   rend ces images directement, éventuellement modifiées par
   `Class.InputActionLabel.ImageColor3|ImageColor3` et
   `Class.InputActionLabel.ImageTransparency|ImageTransparency`.

2. **Images de touches de plateforme** — En l'absence d'images personnalisées, l'étiquette rend
   les images fournies par la plateforme pour les enfants `Class.InputBinding|InputBindings`
   via `Class.UserInputService:GetImageForKeyCode()`, si de telles images sont
   disponibles. Les liaisons composites avec des modificateurs affichent plusieurs icônes avec des séparateurs `+`.

3. **Noms personnalisés** — En l'absence d'images disponibles, si les enfants
   `Class.InputBinding|InputBindings` ont leur
   propriété `Class.InputBinding.DisplayName|DisplayName` définie, l'étiquette
   rend ce texte dans un style défini par
   `Class.InputActionLabel.FontFace|FontFace`,
   `Class.InputActionLabel.TextColor3|TextColor3`,
   `Class.InputActionLabel.TextSize|TextSize`,
   `Class.InputActionLabel.TextTransparency|TextTransparency`,
   `Class.InputActionLabel.TextWrapped|TextWrapped`,
   `Class.InputActionLabel.TextXAlignment|TextXAlignment`, et
   `Class.InputActionLabel.TextYAlignment|TextYAlignment`.

4. **Chaînes de touches de plateforme** — En l'absence de tout ce qui précède, l'étiquette rend
   les chaînes fournies par la plateforme via
   `Class.UserInputService:GetStringForKeyCode()`.

5. Si aucun `Class.InputAction` n'est assigné ou qu'aucun enfant `Class.InputBinding`
   n'existe, l'étiquette rend une icône de remplacement.


InputActionLabel

Cette propriété est similaire à `Class.TextLabel.FontFace` et détermine la
famille de polices, le poids et le style utilisés lorsque l'étiquette se rend en mode texte.


InputActionLabel.FontFace

Détermine la police utilisée pour rendre le texte.


Cette propriété détermine comment les images d'étiquette sont colorisées. Lorsqu'elle est définie sur
blanc, aucune colorisation n'a lieu. Cette propriété est utile pour réutiliser des actifs d'image ; si les images sources sont complètement blanches avec transparence, vous
pouvez définir la couleur de l'ensemble de l'étiquette d'un coup avec cette propriété.


InputActionLabel.ImageColor3

Détermine comment les images d'étiquette rendues seront colorisées.


Cette propriété détermine l'alpha des images d'étiquette rendues. Une valeur de
`0` est complètement opaque et une valeur de `1` est complètement transparente
(invisible).


InputActionLabel.ImageTransparency

Détermine la transparence des images d'étiquette rendues.


L'instance `Class.InputAction` pour laquelle l'étiquette doit automatiquement
résoudre et afficher son raccourci préféré. Lorsque le raccourci change (en raison
d'une réaffectation ou d'un changement d'appareil d'entrée), l'étiquette se met à jour automatiquement.

Définir cela sur `nil` efface l'affichage et montre le remplacement.


InputActionLabel.InputAction

Le `Class.InputAction` dont le raccourci préféré cette étiquette affiche.


Contient le `Datatype.Content` de la première image résolue lorsque l'étiquette
se rend en mode image. Vide lorsqu'elle est en mode texte ou remplacement. C'est
une propriété en lecture seule définie par le moteur lorsque le raccourci est résolu.


InputActionLabel.ResolvedImageContent

Lecture seule. Le contenu d'image résolu actuellement affiché.


Contient la chaîne de nom de touche composée telle que `Ctrl + Shift + Space` lorsque
l'étiquette se rend en mode texte. Vide lorsque l'étiquette se rend en mode image ou
remplacement. C'est une propriété en lecture seule définie par le moteur lorsque le
raccourci est résolu.


InputActionLabel.ResolvedText

La chaîne de nom de touche résolue actuellement affichée.


Cette propriété détermine la couleur de tout le texte rendu par l'étiquette.


InputActionLabel.TextColor3

Contrôle la taille de la police en pixels pour le rendu en mode texte. La valeur est limitée
entre `1` et `200`.


InputActionLabel.TextSize

Détermine la hauteur de ligne du texte en décalages.


Cette propriété détermine la transparence de tout le texte rendu par l'étiquette.


InputActionLabel.TextTransparency

Détermine la transparence du texte rendu.


Lorsque `true`, le texte se rend sur plusieurs lignes dans l'espace de l'étiquette afin que
les lignes de `Class.InputActionLabel.TextSize|TextSize` ne dépassent jamais la
`Class.GuiBase2d.AbsoluteSize` de l'objet. Cela est réalisé en divisant
les longues lignes de texte en plusieurs lignes.


InputActionLabel.TextWrapped

Détermine si le texte se divise en plusieurs lignes dans l'espace de l'étiquette.


Cette propriété détermine l'alignement horizontal du texte rendu dans
l'espace de l'étiquette.


InputActionLabel.TextXAlignment

Détermine l'alignement horizontal du texte rendu.


Cette propriété détermine l'alignement vertical du texte rendu dans
l'espace de l'étiquette.


InputActionLabel.TextYAlignment

Détermine l'alignement vertical du texte rendu.


Un `Class.GuiObject` qui affiche automatiquement le raccourci pour une action
sous forme de texte ou d'image.


`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 manière 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 manière 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 un 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 se rend 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 un 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 se rend 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 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 qu'elle est déplacée.

Les arguments `x` et `y` indiquent les coordonnées à l'écran mises à jour de la souris de l'utilisateur en pixels. Ceux-ci peuvent être utiles pour déterminer l'emplacement de la souris sur le GUI, l'écran, et le delta depuis la position précédente de la souris si elle est suivie 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 :

```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 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 sa 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 vers l'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 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 sa 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 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 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 lorsque 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 lorsque 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 en 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 est dépendant 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 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` 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 de tirage sur l'élément UI à l'aide d'un dispositif tactile. Un **pincement** se produit lorsque deux ou plusieurs doigts 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 UI à l'écran, et est le plus souvent utilisé pour des fonctionnalités de zoom.

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 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 pincement ou de tirage sur l'élément UI à l'aide d'un appareil tactile. La rotation se produit lorsque l'angle de la ligne entre les 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 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 en utilisant 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 tap sur l'élément UI à l'aide d'un appareil tactile. Un tap est un contact rapide et unique 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`). 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 tap 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 un GUI vers une nouvelle position `Datatype.UDim2` dans le temps spécifié en utilisant la `Enum.EasingDirection` et `Enum.EasingStyle` spécifiées.

Cette fonction renverra si le tween va jouer. 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 la _endPosition_.

easingStyle

Le style dans lequel adoucir 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 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 adoucir le GUI vers la _endSize_.

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

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 adoucir le GUI vers la _endSize_ et _endPosition_.

Le style dans lequel adoucir 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 les 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 au moment de l'édition ou de 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`.

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

/reference/engine/classes/InputActionLabel.yaml