`Class.Frame` est un `Class.GuiObject` qui agit comme un conteneur pour d'autres
`Class.GuiObject|GuiObjects`. Vous pouvez l'utiliser pour une interface utilisateur qui s'affiche soit sur un
[écran](/ui/on-screen-containers) de l'utilisateur soit sur une
[surface](/ui/in-experience-containers) dans l'expérience.

<img src="/assets/ui/ui-objects/Frame-Example.jpg" width="840" />

Les `Class.Frame|Frames` sont des conteneurs idéaux pour des mises en page réactives telles que des
[mises en page de liste et flex](/ui/list-flex-layouts), vous permettant de
changer la taille du cadre et d'ajuster dynamiquement comment les éléments de mise en page s'adaptent
à l'intérieur. Les `Class.Frame|Frames` sont également des `Class.GuiObject|GuiObjects` de base, donc
vous pouvez personnaliser des propriétés telles que
`Class.GuiObject.BackgroundColor3|BackgroundColor3`,
`Class.GuiObject.Transparency|Transparency`, appliquer un
[ dégradé de fond](/ui/appearance-modifiers#gradient) ou une
[bordure](/ui/appearance-modifiers#stroke), et plus encore.


Frame

Définit à quoi ressemble le cadre à partir d'une sélection de styles prédéterminés.
Voir `Enum.FrameStyle` pour une description de chaque style.


Frame.Style

Définit à quoi ressemble le cadre à partir d'une sélection de styles prédéterminés.


Un `Class.GuiObject` qui se rend comme un rectangle simple, généralement utilisé comme un
conteneur.


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

Cette propriété détermine la largeur de la bordure du `Class.GuiObject`, en pixels. Définir ceci à 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` coupera (rendra invisible) toute portion des éléments GUI descendants qui seraient autrement rendus en dehors des limites du rectangle.

Notez que `Class.GuiObject.Rotation|Rotation` n'est pas pris en charge par cette propriété. Si celui-ci ou tout ancêtre GUI a une `Class.GuiObject.Rotation|Rotation` **non nulle**, cette propriété est **ignorée** et les éléments GUI descendants seront rendus, quelle que soit la valeur de cette propriété.

GuiObject.ClipsDescendants

Détermine si les `Class.GuiObject|GuiObjects` descendants 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 pressé 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.

GuiObject.InputSink

Détermine si le `Class.GuiButton` peut être interagi avec ou non, ou
si l'`Enum.GuiState|GuiState` de l'`Class.GuiObject` est en train de changer 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 le
  `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 le `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`, le
  `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.GuiObject.GuiState|GuiState` se comportera normalement à nouveau.


GuiObject.Interactable

Détermine si le `Class.GuiButton` peut être interagi avec ou non, ou
si l'`Enum.GuiState|GuiState` de l'`Class.GuiObject` est en train de changer ou
non.


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

Les `Class.GuiObject|GuiObjects` sont triés par ordre croissant où des valeurs plus
basses ont la priorité sur des valeurs plus élevées. Les objets avec des
valeurs égales se retournent à 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, c'est une bonne pratique 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 les é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 de l'`Class.GuiObject` lorsqu'il est utilisé avec un
`Class.UIGridStyleLayout`.


Cet exemple démontre comment activer la navigation avec un Gamepad à travers une grille d'éléments `GuiObject|GUI` sans avoir à connecter manuellement les propriétés `Class.GuiObject.NextSelectionUp`, `Class.GuiObject.NextSelectionDown`, `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 se base sur cela pour définir les propriétés NextSelection pour tous les `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()|récupère 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 au début et à la fin des rangées (à l'exclusion du premier et du dernier élément) de passer à la rangée suivante et précédente. Si un élément n'existe pas à gauche, à droite, au-dessus ou en dessous, le NextSelection restera nil et le déplacement du sélecteur Gamepad 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'un gamepad, au cas où vous n'auriez pas de gamepad à tester. Cette portion de code sélectionne initialement l'élément 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 [manette](/input/gamepad) vers le bas. Si cette
propriété est vide, déplacer la manette vers le bas ne changera pas le GUI sélectionné.

Déplacer le sélecteur de la manette 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 si ce 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 manette
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 [manette](/input/gamepad) à gauche. Si cette
propriété est vide, déplacer la manette à gauche ne changera pas le
GUI sélectionné.

Déplacer le sélecteur de la manette à 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 si ce 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 manette
est déplacé à gauche.


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

Déplacer le sélecteur de la manette à 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 si ce 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 manette
est déplacé à droite.


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

Déplacer le sélecteur de la manette vers le haut 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 si ce 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.NextSelectionDown|NextSelectionDown`,
`Class.GuiObject.NextSelectionLeft|NextSelectionLeft`,
`Class.GuiObject.NextSelectionRight|NextSelectionRight`.


GuiObject.NextSelectionUp

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


Cette propriété détermine la position pixel et scalaire de l'`Class.GuiObject`
en utilisant un `Datatype.UDim2`. La position est centrée autour du
`Class.GuiObject.AnchorPoint` de l'objet.

La position scalaire est relative à la taille de l'élément GUI parent, si
il y en a un.

Les portions pixel de la valeur `Datatype.UDim2` sont les mêmes peu
importe la taille du parent GUI. Les valeurs représentent la position de l'objet
en pixels. La position pixel réelle d'un objet peut être lue à partir de la
propriété `Class.GuiBase2d.AbsolutePosition`.


GuiObject.Position

Détermine la position pixel et scalaire de l'`Class.GuiObject`.


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