Attention: Here be dragons
This is the latest
(unstable) version of this documentation, which may document features
not available in or compatible with released stable versions of Godot.
Checking the stable version of the documentation...
Control
Hérite de : CanvasItem < Node < Object
Hérité par : BaseButton, ColorRect, Container, GraphEdit, ItemList, Label, LineEdit, MenuBar, NinePatchRect, Panel, Range, ReferenceRect, RichTextLabel, Separator, TabBar, TextEdit, TextureRect, Tree, VideoStreamPlayer, VirtualJoystick
Classe de base pour tous les contrôles GUI. Adapte sa position et sa taille en fonction de son contrôle parent.
Description
Base class for all UI-related nodes. Control features a bounding rectangle that defines its extents, an anchor position relative to its parent control or the current viewport, and offsets relative to the anchor. The offsets update automatically when the node, any of its parents, or the screen size change.
For more information on Godot's UI system, anchors, offsets, and containers, see the related tutorials in the manual. To build flexible UIs, you'll need a mix of UI elements that inherit from Control and Container nodes.
Note: Since both Node2D and Control inherit from CanvasItem, they share several concepts from the class such as the CanvasItem.z_index and CanvasItem.visible properties.
User Interface nodes and input
Godot propagates input events via viewports. Each Viewport is responsible for propagating InputEvents to their child nodes. As the SceneTree.root is a Window, this already happens automatically for all UI elements in your game.
Input events are propagated through the SceneTree from the root node to all child nodes by calling Node._input(). For UI elements specifically, it makes more sense to override the virtual method _gui_input(), which filters out unrelated input events, such as by checking z-order, mouse_filter, focus, or if the event was inside of the control's bounding box.
Call accept_event() so no other node receives the event. Once you accept an input, it becomes handled so Node._unhandled_input() will not process it.
Only one Control node can be in focus. Only the node in focus will receive events. To get the focus, call grab_focus(). Control nodes lose focus when another node grabs it, or if you hide the node in focus. Focus will not be represented visually if gained via mouse/touch input, only appearing with keyboard/gamepad input (for accessibility), or via grab_focus().
Set mouse_filter to MOUSE_FILTER_IGNORE to tell a Control node to ignore mouse or touch events. You'll need it if you place an icon on top of a button.
Theme resources change the control's appearance. The theme of a Control node affects all of its direct and indirect children (as long as a chain of controls is uninterrupted). To override some of the theme items, call one of the add_theme_*_override methods, like add_theme_font_override(). You can also override theme items in the Inspector.
Note: Theme items are not Object properties. This means you can't access their values using Object.get() and Object.set(). Instead, use the get_theme_* and add_theme_*_override methods provided by this class.
Tutoriels
Propriétés
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
physics_interpolation_mode |
|
|
|
||
|
||
|
||
|
||
|
||
|
||
|
||
BitField[SizeFlags] |
|
|
|
||
BitField[SizeFlags] |
|
|
|
||
|
||
|
||
|
Méthodes
Signaux
focus_entered() 🔗
Émis lorsque le nœud gagne le focus.
focus_exited() 🔗
Émis lorsque le nœud perd le focus.
gui_input(event: InputEvent) 🔗
Émis quand le nœud reçoit un InputEvent.
maximum_size_changed() 🔗
Emitted when the node's maximum size changes.
minimum_size_changed() 🔗
Émis quand la taille minimale du nœud change.
mouse_entered() 🔗
Émis quand le curseur de la souris entre dans la zone visible du contrôle (ou un de ses enfants), qui n'est pas masqué derrière d'autres Contrôles ou Fenêtres, fourni son mouse_filter, laisse l’événement l'atteindre, et peu importe s’il est actuellement ciblé ou non.
Note: CanvasItem.z_index n'affecte pas quel Contrôle reçoit le signal.
mouse_exited() 🔗
Émis lorsque le curseur de la souris quitte la zone visible du contrôle (et de tout contrôle enfant), qui n'est pas occlus derrière d'autres Controls ou Windows, à condition que son mouse_filter permette à l'événement de l'atteindre et peu importe de s'il a le focus ou non.
Note : CanvasItem.z_index n'a pas d'incidence sur quel Control reçoit le signal.
Note : Si vous voulez vérifier si la souris a vraiment quitté la zone, en ignorant les nœuds supérieurs, vous pouvez utiliser un code comme ceci :
func on_mouse_exited():
if not Rect2(Vector2(), rect_size).has_point(get_local_mouse_position()):
# Ne survole pas la zone.
resized() 🔗
Émis lorsque le contrôle change de taille.
size_flags_changed() 🔗
Émis lorsque l'un des drapeaux de taille change. Voir size_flags_horizontal et size_flags_vertical.
theme_changed() 🔗
Émis lorsque la notification NOTIFICATION_THEME_CHANGED est envoyée.
Énumérations
enum FocusMode: 🔗
FocusMode FOCUS_NONE = 0
Le nœud ne peut récupérer le focus. À utiliser avec focus_mode.
FocusMode FOCUS_CLICK = 1
Le nœud ne reçoit le focus que pour les clics de la souris. À utiliser avec focus_mode.
FocusMode FOCUS_ALL = 2
Le nœud peut obtenir le focus lors d'un clic de souris, en utilisant les flèches et la touche de tabulation du clavier ou en utilisant les boutons de la croix directionnelle d'une manette. À utiliser avec focus_mode.
FocusMode FOCUS_ACCESSIBILITY = 3
Le nœud ne reçoit le focus que lorsqu'un lecteur d'écran est actif. À utiliser avec focus_mode.
enum FocusBehaviorRecursive: 🔗
FocusBehaviorRecursive FOCUS_BEHAVIOR_INHERITED = 0
Hérite du focus_behavior_recursive du contrôle parent. S'il n'y a pas de contrôle parent, cela revient à FOCUS_BEHAVIOR_ENABLED.
FocusBehaviorRecursive FOCUS_BEHAVIOR_DISABLED = 1
Empêche au contrôle d'obtenir le focus. get_focus_mode_with_override() renverra FOCUS_NONE.
FocusBehaviorRecursive FOCUS_BEHAVIOR_ENABLED = 2
Permet au contrôle d'obtenir le focus, en fonction de focus_mode. Cela peut être utilisé pour ignorer le focus_behavior_recursive du parent. get_focus_mode_with_override() renverra le focus_mode.
enum MouseBehaviorRecursive: 🔗
MouseBehaviorRecursive MOUSE_BEHAVIOR_INHERITED = 0
Hérite du mouse_behavior_recursive du contrôle parent. S'il n'y a pas de contrôle parent, cela renvient à MOUSE_BEHAVIOR_ENABLED.
MouseBehaviorRecursive MOUSE_BEHAVIOR_DISABLED = 1
Empêche le contrôle de recevoir l'entrée de la souris. get_mouse_filter_with_override() renverra MOUSE_FILTER_IGNORE.
MouseBehaviorRecursive MOUSE_BEHAVIOR_ENABLED = 2
Allows the control to receive mouse input, depending on the mouse_filter. This can be used to ignore the parent's mouse_behavior_recursive. get_mouse_filter_with_override() will return the mouse_filter.
enum CursorShape: 🔗
CursorShape CURSOR_ARROW = 0
Affiche le curseur système de la souris quand l'utilisateur survole le nœud. À utiliser avec mouse_default_cursor_shape.
CursorShape CURSOR_IBEAM = 1
Affiche le curseur de la souris en forme de I lorsque l'utilisateur survole le nœud. Le pointeur en I a une forme semblable à un "I". Il signale à l'utilisateur qu'il peut insérer ou surligner du texte.
CursorShape CURSOR_POINTING_HAND = 2
Afficher le curseur de la main qui pointe quand il passe sur ce nœud.
CursorShape CURSOR_CROSS = 3
Affiche le curseur en croix du système quand l'utilisateur survole ce nœud.
CursorShape CURSOR_WAIT = 4
Affiche le curseur d'attente du système quand l'utilisateur survole ce nœud. Souvent un sablier.
CursorShape CURSOR_BUSY = 5
Affiche le curseur d'occupation du système quand l'utilisateur survole ce nœud. Souvent une flèche avec un petit sablier.
CursorShape CURSOR_DRAG = 6
Affiche le curseur de la souris de déposé-glissé, souvent un poing fermé ou un symbole de croix, lorsque l'utilisateur survole le nœud. Ça précise à l'utilisateur qu'il déplace actuellement un objet, comme un nœud dans le dock de Scene.
CursorShape CURSOR_CAN_DROP = 7
Affiche le curseur de la souris lorsque l'utilisateur survole le nœud. Ça peut être une main ouverte. Ça précise à l'utilisateur qu'il peut déposer un élément qu'il était en traint de déplacer, comme un nœud dans le dock de Scene.
CursorShape CURSOR_FORBIDDEN = 8
Affiche le curseur de souris d'interdition système lorsque l'utilisateur survole le nœud. C'est souvent un cercle barré.
CursorShape CURSOR_VSIZE = 9
Afficher le curseur de souris de redimensionnement vertical lorsque l'utilisateur survole le nœud. Une flèche verticale à double tête. Ça précise à l'utilisateur qu'il peut redimensionner la fenêtre ou le panneau verticalement.
CursorShape CURSOR_HSIZE = 10
Affiche le curseur de la souris de redimensionnement horizontal lorsque l'utilisateur survole le nœud. Une flèche horizontale à double tête. Ça précise à l'utilisateur qu'il peut redimensionner la fenêtre ou le panneau horizontalement.
CursorShape CURSOR_BDIAGSIZE = 11
Affiche le curseur de la souris de redimensionnement de la fenêtre lorsque l'utilisateur survole le nœud. Le curseur est une flèche à double tête qui va du bas à gauche au sommet à droite. Ça précise à l'utilisateur qu'il peut redimensionner la fenêtre ou le panneau à la fois horizontalement et verticalement.
CursorShape CURSOR_FDIAGSIZE = 12
Affiche le curseur de la souris de redimensionnement de la fenêtre lorsque l'utilisateur survole le nœud. Le curseur est une flèche à double tête qui va du haut à gauche au bas à droite, le contraire de CURSOR_BDIAGSIZE. Ça précise à l'utilisateur qu'il peut redimensionner la fenêtre ou le panneau à la fois horizontalement et verticalement.
CursorShape CURSOR_MOVE = 13
Affiche le curseur de la souris de déplacement lorsque l'utilisateur survole le nœud. Il montre 2 flèches doubles à un angle de 90 degrés. Ça précise à l'utilisateur qu'il peut déplacer un élément d'interface librement.
CursorShape CURSOR_VSPLIT = 14
Affiche le curseur système de la souris avec un séparateur vertical lorsque l'utilisateur survole le nœud. Sur Windows, il est identique à CURSOR_VSIZE.
CursorShape CURSOR_HSPLIT = 15
Affiche le curseur système de la souris avec un séparateur horizontal lorsque l'utilisateur survole le nœud. Sur Windows, il est identique à CURSOR_HSIZE.
CursorShape CURSOR_HELP = 16
Affiche le curseur système de la souris pour l'aide lorsque l'utilisateur survole le nœud, avec un point d'interrogation.
enum LayoutPreset: 🔗
LayoutPreset PRESET_TOP_LEFT = 0
Magnétise toutes les 4 ancres jusqu'au coin gauche supérieur du rectangle délimitant du contrôle parent. À utiliser avec set_anchors_preset().
LayoutPreset PRESET_TOP_RIGHT = 1
Magnétise toutes les 4 ancres au coin droit du rectangle délimitant du contrôle parent. À utiliser avec set_anchors_preset().
LayoutPreset PRESET_BOTTOM_LEFT = 2
Magnétise toutes les 4 ancres au coin bas-gauche du rectangle délimitant du contrôle parent. À utiliser avec set_anchors_preset().
LayoutPreset PRESET_BOTTOM_RIGHT = 3
Magnétise toutes les 4 ancres au coin bas-droit du rectangle délimitant du contrôle parent. À utiliser avec set_anchors_preset().
LayoutPreset PRESET_CENTER_LEFT = 4
Magnétise toutes les 4 ancres au centre du bord gauche du rectangle délimitant du contrôle parent. À utiliser avec set_anchors_preset().
LayoutPreset PRESET_CENTER_TOP = 5
Magnétise toutes les 4 ancres au centre du bord supérieur du rectangle délimitant du contrôle parent. À utiliser avec set_anchors_preset().
LayoutPreset PRESET_CENTER_RIGHT = 6
Magnétise toutes les 4 ancres au centre du bord droit du rectangle délimitant du contrôle parent. À utiliser avec set_anchors_preset().
LayoutPreset PRESET_CENTER_BOTTOM = 7
Magnétise toutes les 4 ancres au centre du bord du bas du rectangle délimitant du contrôle parent. À utiliser avec set_anchors_preset().
LayoutPreset PRESET_CENTER = 8
Magnétise les 4 ancres au centre du rectangle délimitant du contrôle parent. À utiliser avec set_anchors_preset().
LayoutPreset PRESET_LEFT_WIDE = 9
Magnétise les 4 ancres au bord gauche du contrôle parent. La marge gauche devient alors relative au bord gauche et à la marge supérieure relative au coin supérieur gauche du nœud parent. Utilisez avec set_anchors_preset().
LayoutPreset PRESET_TOP_WIDE = 10
Aimante les 4 ancres au bord supérieur du contrôle parent. Le décalage gauche devient alors relatif au coin supérieur gauche, le décalage du haut relatif au bord supérieur, et le décalage droit relatif au coin supérieur droit du nœud parent. À utiliser avec set_anchors_preset().
LayoutPreset PRESET_RIGHT_WIDE = 11
Aimante les 4 ancres au bord droit du contrôle parent. Le décalage droit devient alors relatif au bord droit et le décalage du haut relatif au coin supérieur droit. À utiliser avec set_anchors_preset().
LayoutPreset PRESET_BOTTOM_WIDE = 12
Magnétise les 4 ancres au bord inférieur du contrôle parent. La marge gauche devient alors relative au coin inférieur gauche, à la marge inférieure relative au bord inférieur, et à la marge droite relative au coin inférieur droit du nœud parent. À utiliser avec set_anchors_preset().
LayoutPreset PRESET_VCENTER_WIDE = 13
Magnétise les 4 ancres sur une ligne verticale qui coupe le contrôle parent en deux. À utiliser avec set_anchors_preset().
LayoutPreset PRESET_HCENTER_WIDE = 14
Magnétise les 4 ancres sur une ligne horizontale qui coupe le contrôle parent en deux. À utiliser avec set_anchors_preset().
LayoutPreset PRESET_FULL_RECT = 15
Magnétise toutes les 4 ancres aux angles respectifs du contrôle parent. Définissez les 4 marges à 0 après avoir appliqué ce préréglage et le Control s'adaptera à son contrôle parent. Utilisez avec set_anchors_preset().
enum LayoutPresetMode: 🔗
LayoutPresetMode PRESET_MODE_MINSIZE = 0
Le contrôle sera redimensionné à sa taille minimale.
LayoutPresetMode PRESET_MODE_KEEP_WIDTH = 1
La largeur du contrôle ne changera pas.
LayoutPresetMode PRESET_MODE_KEEP_HEIGHT = 2
La hauteur du contrôle ne changera pas.
LayoutPresetMode PRESET_MODE_KEEP_SIZE = 3
La taille du contrôle ne changera pas.
flags SizeFlags: 🔗
SizeFlags SIZE_SHRINK_BEGIN = 0
Indique au Container parent d'aligner le nœud sur son début, soit au bord supérieur soit au bord gauche. Il est mutuellement exclusif avec SIZE_FILL et les autres drapeaux de rétrécissement de la taille, mais peut être utilisé avec SIZE_EXPAND dans quelques conteneurs. À utiliser avec size_flags_horizontal et size_flags_vertical.
Note : Définir ce drapeau est égal à ne pas avoir de drapeau de taille.
SizeFlags SIZE_FILL = 1
Indique au Container parent d'étendre les limites de ce nœud pour remplir tout l'espace disponible sans pousser d'autre nœuds. Il est mutuellement exclusif avec les autres drapeaux de rétrécissement de la taille. À utiliser avec size_flags_horizontal et size_flags_vertical.
SizeFlags SIZE_EXPAND = 2
Signale au Container parent de laisser ce nœud prendre tout l'espace disponible sur l'axe spécifié. Si plusieurs nœuds voisins sont prêts à s'étendre, ils partagent l'espace en fonction de leur rapport d'étirement. Voir size_flags_stretch_ratio. À utiliser avec size_flags_horizontal et size_flags_vertical.
SizeFlags SIZE_EXPAND_FILL = 3
Définit les drapeaux de taille du nœud pour à la fois remplir et s'étendre. Voir SIZE_FILL et SIZE_EXPAND pour plus d'informations.
SizeFlags SIZE_SHRINK_CENTER = 4
Indique au Container parent de centrer le nœud dans l'espace disponible. Il est mutuellement exclusif avec SIZE_FILL et les autres drapeau de rétrécissement de la taille, mais peut être utilisé avec SIZE_EXPAND dans quelques conteneurs. À utiliser avec size_flags_horizontal et size_flags_vertical.
SizeFlags SIZE_SHRINK_END = 8
Indique au Container parent d'aligner le nœud sur sa fin, soit en bas, soit sur le bord droit. Il est mutuellement exclusif avec SIZE_FILL et les autres drapeau de rétrécissement de la taille, mais peut être utilisé avec SIZE_EXPAND dans quelques conteneurs. À utiliser avec size_flags_horizontal et size_flags_vertical.
enum MouseFilter: 🔗
MouseFilter MOUSE_FILTER_STOP = 0
Le contrôle recevra les événements d'entrée de mouvement de la souris et les événements d'entrée de bouton de la souris via _gui_input() si vous cliquez dessus. Le contrôle recevra également les signaux mouse_entered et mouse_exited. Ces événements sont automatiquement marqués comme traités, et ils ne se propagent pas vers d'autres contrôles. Cela permet également de bloquer les signaux dans d'autres contrôles.
MouseFilter MOUSE_FILTER_PASS = 1
The control will receive mouse movement input events and mouse button input events if clicked on through _gui_input(). The control will also receive the mouse_entered and mouse_exited signals.
If this control does not handle the event, the event will propagate up to its parent control if it has one. The event is bubbled up the node hierarchy until it reaches a non-CanvasItem, a control with MOUSE_FILTER_STOP, or a CanvasItem with CanvasItem.top_level enabled. This will allow signals to fire in all controls it reaches. If no control handled it, the event will be passed to Node._shortcut_input() for further processing.
MouseFilter MOUSE_FILTER_IGNORE = 2
La contrôle ne recevra aucun événement d'entrée de la souris ou d'évènement de bouton de la souris si cliqué via _gui_input(). Le contrôle ne recevra aussi pas les signaux mouse_entered et mouse_exited. Ceci ne bloquera pas d'autres contrôles de recevoir ces événements ou de déclencher les signaux. Les événements ignorés ne seront pas gérés automatiquement. Si un enfant a MOUSE_FILTER_PASS et qu'un événement a été transmis à ce contrôle, l'événement se propagera vers le haut vers le parent du contrôle.
Note : Si le contrôle a reçu mouse_entered mais pas mouse_exited, changer mouse_filter à MOUSE_FILTER_IGNORE causera l'émission de mouse_exited.
enum GrowDirection: 🔗
GrowDirection GROW_DIRECTION_BEGIN = 0
Le contrôle va croître à gauche ou en haut pour compenser si sa taille minimale est plus grande que sa taille actuelle selon l'axe correspondant.
GrowDirection GROW_DIRECTION_END = 1
Le contrôle va croître à droite ou en bas pour compenser si sa taille minimale est plus grande que sa taille actuelle selon l'axe correspondant.
GrowDirection GROW_DIRECTION_BOTH = 2
Le contrôle va croître dans les deux directions de façon égale pour compenser si sa taille minimale est plus grande que sa taille actuelle.
enum Anchor: 🔗
Anchor ANCHOR_BEGIN = 0
Magnétise l'un des 4 côtés d'ancrage à l'origine de l'ancrage Rect, en haut à gauche. Utilisez-le avec l'une des variables membres anchor_*, comme anchor_left. Pour modifier les 4 ancres à la fois, utilisez set_anchors_preset().
Anchor ANCHOR_END = 1
Magnétise l'un des 4 côtés d'ancrage à l'extrémité de l'extrémité Rect, en bas à droite. Utilisez-le avec l'une des variables membres anchor_*, comme anchor_left. Pour modifier les 4 ancres à la fois, utilisez set_anchors_preset().
enum LayoutDirection: 🔗
LayoutDirection LAYOUT_DIRECTION_INHERITED = 0
Direction de mise en page automatique, déterminée à partir de la direction de mise en page du contrôle parent.
LayoutDirection LAYOUT_DIRECTION_APPLICATION_LOCALE = 1
Direction de mise en page automatique, déterminée à partir de la langue actuelle. La direction de mise en page de droite à gauche est automatiquement utilisée pour les langues qui l'exigent comme l'arabe et l'hébreu, mais seulement si un fichier de traduction valide est chargé pour la langue donnée (sauf si la-dite langue est configurée comme un repli dans ProjectSettings.internationalization/locale/fallback). Pour toutes les autres langues (ou si aucun fichier de traduction valide n'est trouvé par Godot), la direction de mise en page de gauche à droite est utilisée. Si vous utilisez TextServerFallback (ProjectSettings.internationalization/rendering/text_driver), la direction de mise en page de gauche à droite est toujours utilisée peu importe la langue. La direction de mise en page de droite à gauche peut aussi être forcée en utilisant ProjectSettings.internationalization/rendering/force_right_to_left_layout_direction.
LayoutDirection LAYOUT_DIRECTION_LTR = 2
Direction de disposition de gauche à droite.
LayoutDirection LAYOUT_DIRECTION_RTL = 3
Disposition de direction de droite à gauche.
LayoutDirection LAYOUT_DIRECTION_SYSTEM_LOCALE = 4
Direction de mise en page automatique, déterminée à partir de la langue du système. La direction de mise en page de droite à gauche est automatiquement utilisée pour les langues qui l'exigent comme l'arabe et l'hébreu, mais seulement si un fichier de traduction valide est chargé pour la langue donnée. Pour toutes les autres langues (ou si aucun fichier de traduction valide n'est trouvé par Godot), la direction de mise en page de gauche à droite est utilisée. Si vous utilisez TextServerFallback (ProjectSettings.internationalization/rendering/text_driver), la direction de mise en page de gauche à droite est toujours utilisée peu importe la langue.
LayoutDirection LAYOUT_DIRECTION_MAX = 5
Représente la taille de l'énumération LayoutDirection.
LayoutDirection LAYOUT_DIRECTION_LOCALE = 1
Obsolète : Use LAYOUT_DIRECTION_APPLICATION_LOCALE instead.
enum TextDirection: 🔗
TextDirection TEXT_DIRECTION_INHERITED = 3
La direction d'écriture du texte est la même que la direction de mise en page.
TextDirection TEXT_DIRECTION_AUTO = 0
Direction d'écriture de texte automatique, déterminée à partir de la langue actuelle et du contenu du texte.
TextDirection TEXT_DIRECTION_LTR = 1
Direction d'écriture de texte de gauche à droite.
TextDirection TEXT_DIRECTION_RTL = 2
Direction d'écriture de texte de droite à gauche.
Constantes
NOTIFICATION_RESIZED = 40 🔗
Envoyé quand le nœud change de taille. Utilisez size pour obtenir la nouvelle taille.
NOTIFICATION_MOUSE_ENTER = 41 🔗
Envoyé quand le curseur de la souris entre dans la zone visible du contrôle (ou un de ses enfants), qui n'est pas masqué derrière d'autres Contrôles ou Fenêtres, fourni son mouse_filter, laisse l’événement l'atteindre, et peu importe s’il est actuellement ciblé ou non.
Note: CanvasItem.z_index n'affecte pas quel Contrôle reçoit la notification.
Voir aussi NOTIFICATION_MOUSE_ENTER_SELF.
NOTIFICATION_MOUSE_EXIT = 42 🔗
Envoyé quand le curseur de la souris sort de la zone visible du contrôle (ou un de ses enfants), qui n'est pas masqué derrière d'autres Contrôles ou Fenêtres, fourni son mouse_filter, laisse l’événement l'atteindre, et peu importe s’il est actuellement ciblé ou non.
Note: CanvasItem.z_index n'affecte pas quel Contrôle reçoit la notification.
Voir aussi NOTIFICATION_MOUSE_EXIT_SELF.
NOTIFICATION_MOUSE_ENTER_SELF = 60 🔗
Expérimental : The reason this notification is sent may change in the future.
Envoyé quand le curseur de la souris entre dans la zone visible du contrôle, qui n'est pas masqué derrière d'autres Contrôles ou Fenêtres, fourni son mouse_filter, laisse l’événement l'atteindre, et peu importe s’il est actuellement ciblé ou non.
Note: CanvasItem.z_index n'affecte pas quel Contrôle reçoit la notification.
Voir aussi NOTIFICATION_MOUSE_ENTER.
NOTIFICATION_MOUSE_EXIT_SELF = 61 🔗
Expérimental : The reason this notification is sent may change in the future.
Envoyé quand le curseur de la souris sort de la zone visible du contrôle, qui n'est pas masqué derrière d'autres Contrôles ou Fenêtres, fourni son mouse_filter, laisse l’événement l'atteindre, et peu importe s’il est actuellement ciblé ou non.
Note: CanvasItem.z_index n'affecte pas quel Contrôle reçoit la notification.
Voir aussi NOTIFICATION_MOUSE_EXIT.
NOTIFICATION_FOCUS_ENTER = 43 🔗
Envoyé lorsque le nœud reçoit le focus.
NOTIFICATION_FOCUS_EXIT = 44 🔗
Sent when the node loses focus.
This notification is sent in reversed order.
NOTIFICATION_THEME_CHANGED = 45 🔗
Envoyé si le nœud a besoin de rafraîchir ses éléments de thème. Cela arrive dans l'un des cas suivants :
La propriété theme est changée sur ce nœud ou sur un de ses ancêtres.
La propriété theme_type_variation est changée sur ce nœud.
Une des redéfinitions d'une des propriétés du thème du nœud est changée.
Le nœud entre dans l'arborescence de la scène.
Note : Pour plus d'optimisation, cette notification ne sera pas envoyée pour les changements qui se passent pendant que ce nœud est en dehors de l'arborescence de la scène. À la place, toues les mises à jour d'éléments de thème peuvent être appliqués en une fois dès que le nœud entre dans la hiérarchie de la scène.
Note : Cette notification est reçue aux côtés de Node.NOTIFICATION_ENTER_TREE, donc si vous instanciez une scène, les nœuds enfants ne seront pas encore initialisés. Vous pouvez l'utiliser pour configurer les thèmes pour ce nœud, les nœuds d'enfants créés à partir de script, ou si vous voulez accéder aux nœuds enfants ajoutés dans l'éditeur, assurez-vous que le nœud est prêt en utilisant Node.is_node_ready().
func _notification(quoi):
if quoi == NOTIFICATION_THEME_CHANGED:
if not is_node_ready():
await ready # Attendre jusqu'au signal ready (prêt)
$Label.add_theme_color_override("font_color", Color.YELLOW)
NOTIFICATION_SCROLL_BEGIN = 47 🔗
Envoyé lorsque ce nœud est à l'intérieur d'un ScrollContainer qui a commencé à être défilé lors du glissement de la zone défilante avec un événement tactile. Cette notification n'est pas envoyée lors du défilement en glissant la barre de défilement, en défilant avec la molette de la souris ou en défilant avec des événements clavier/manette.
Note : Ce signal n'est émis que sur Android ou iOS, ou sur les plateformes de bureau/web lorsque ProjectSettings.input_devices/pointing/emulate_touch_from_mouse est activé.
NOTIFICATION_SCROLL_END = 48 🔗
Envoyé lorsque ce nœud est à l'intérieur d'un ScrollContainer qui a arrêté d'être défilé lors du glissement de la zone défilante avec un événement tactile. Cette notification n'est pas envoyée lors du défilement en glissant la barre de défilement, en défilant avec la molette de la souris ou en défilant avec des événements clavier/manette.
Note : Ce signal n'est émis que sur Android ou iOS, ou sur les plateformes de bureau/web lorsque ProjectSettings.input_devices/pointing/emulate_touch_from_mouse est activé.
NOTIFICATION_LAYOUT_DIRECTION_CHANGED = 49 🔗
Envoyée lorsque la direction de mise en page du contrôle est changée de LTR ou RTL ou vice versa. Cette notification est propagée aux nœuds Control enfants suite à une modification de layout_direction.
Descriptions des propriétés
Array[NodePath] accessibility_controls_nodes = [] 🔗
Les chemins vers les nœuds qui sont contrôlés par ce nœud.
Array[NodePath] accessibility_described_by_nodes = [] 🔗
Les chemins vers les nœuds qui décrivent ce noeud.
String accessibility_description = "" 🔗
La description facilement lisible du nœud qui est rapportée aux applications d'assistance.
Array[NodePath] accessibility_flow_to_nodes = [] 🔗
The paths to the nodes which this node flows into.
Array[NodePath] accessibility_labeled_by_nodes = [] 🔗
Les chemins vers les nœuds qui étiquettent ce nœud.
AccessibilityLiveMode accessibility_live = 0 🔗
void set_accessibility_live(value: AccessibilityLiveMode)
AccessibilityLiveMode get_accessibility_live()
Le mode avec lequel une région dynamique se met à jour. Une région dynamique est un Node qui est mis à jour à la suite d'un événement externe lorsque le focus de l'utilisateur peut être ailleurs.
String accessibility_name = "" 🔗
Le nom facilement lisible du nœud qui est rapporté aux applications d'assistance.
Ancre le bord inférieur du nœud à l'origine, le centre ou la fin de son contrôle parent. Cela modifie comment le décalage du bas se met à jour lorsque le nœud se déplace ou change de taille. Vous pouvez utiliser une des constantes Anchor pour plus de facilité.
Ancre le bord gauche du nœud à l'origine, le centre ou la fin de son contrôle parent. Cela modifie comment le décalage gauche se met à jour lorsque le nœud se déplace ou change de taille. Vous pouvez utiliser une des constantes Anchor pour plus de facilité.
Ancre le bord droit du nœud à l'origine, le centre ou la fin de son contrôle parent. Cela modifie comment le décalage droit se met à jour lorsque le nœud se déplace ou change de taille. Vous pouvez utiliser une des constantes Anchor pour plus de facilité.
Ancre le bord supérieur du nœud à l'origine, le centre ou la fin de son contrôle parent. Cela modifie comment le décalage du haut se met à jour lorsque le nœud se déplace ou change de taille. Vous pouvez utiliser une des constantes Anchor pour plus de facilité.
Obsolète : Use Node.auto_translate_mode and Node.can_auto_translate() instead.
Active/désactive si du texte devrait automatiquement changer en sa version traduite selon la langue actuelle.
Active si le rendu des nœuds basés sur CanvasItem enfants doit être limité au rectangle de ce contrôle. Si true, les parties des enfants qui seraient normalement visibles en-dehors du rectangle de ce contrôle ne seront pas rendues et ne recevront pas d'entrées.
Vector2 custom_maximum_size = Vector2(-1, -1) 🔗
The maximum size of this Control's bounding rectangle. If set to a value greater than or equal to (0, 0), the node's bounding rectangle will never exceed this size. A value below (0, 0) means there is no maximum size.
Note: The final effective maximum size may be subject to parent Container sizing and propagated maximum sizes. See also: get_combined_maximum_size().
Note: Not all Control subtypes handle a custom maximum size gracefully, which may lead to unexpected behavior if the control's contents exceed this size.
Note: This value has priority over custom_minimum_size. For example, if you set custom_maximum_size to (100, 100) and custom_minimum_size to (200, 200), the resulting size will be (100, 100).
Note: It is recommended to use get_bound_minimum_size() instead of get_combined_minimum_size() when using this property, as the former respects maximum size limits when calculating the minimum size, while the latter does not.
Vector2 custom_minimum_size = Vector2(0, 0) 🔗
The minimum size of the node's bounding rectangle. If you set it to a value greater than (0, 0), the node's bounding rectangle will always have at least this size. Note that Control nodes have their internal minimum size returned by get_minimum_size(). It depends on the control's contents, like text, textures, or style boxes. The actual minimum size is the maximum value of this property and the internal minimum size (see get_combined_minimum_size()).
Note: custom_maximum_size has priority over this property. For example, if you set custom_minimum_size to (200, 200) and custom_maximum_size to (100, 100), the resulting size will be (100, 100).
FocusBehaviorRecursive focus_behavior_recursive = 0 🔗
void set_focus_behavior_recursive(value: FocusBehaviorRecursive)
FocusBehaviorRecursive get_focus_behavior_recursive()
Détermine quels contrôles peuvent avoir le focus ensemble avec focus_mode. Voir get_focus_mode_with_override(). Comme le comportement par défaut est FOCUS_BEHAVIOR_INHERITED, cela peut être utilisé pour empêcher tous les contrôles enfants d'avoir le focus.
Détermine quels contrôles peuvent recevoir le focus. Celui-ci ne peut être fait que sur un seul contrôle à la fois, ce contrôle recevra alors les événements de clavier, de manette et de souris dans _gui_input(). Utilisez get_focus_mode_with_override() pour déterminer si un contrôle peut capturer le focus, car focus_behavior_recursive l'affecte également. Voir aussi grab_focus().
NodePath focus_neighbor_bottom = NodePath("") 🔗
Indique à Godot à quel nœud il devrait donner le focus si l'utilisateur appuie sur la flèche bas sur le clavier ou bas sur une manette par défaut. Vous pouvez modifier la touche en éditant l'action d'entrée ProjectSettings.input/ui_down. Le nœud doit être un Control. Si cette propriété n'est pas définie, Godot donnera le focus au Control le plus proche en-dessous de celui-ci.
NodePath focus_neighbor_left = NodePath("") 🔗
Indique à Godot à quel nœud il devrait donner le focus si l'utilisateur appuie sur la flèche gauche sur le clavier ou gauche sur une manette par défaut. Vous pouvez modifier la touche en éditant l'action d'entrée ProjectSettings.input/ui_left. Le nœud doit être un Control. Si cette propriété n'est pas définie, Godot donnera le focus au Control le plus proche à gauche de celui-ci.
NodePath focus_neighbor_right = NodePath("") 🔗
Indique à Godot à quel nœud il devrait donner le focus si l'utilisateur appuie sur la flèche droite sur le clavier ou droite sur une manette par défaut. Vous pouvez modifier la touche en éditant l'action d'entrée ProjectSettings.input/ui_right. Le nœud doit être un Control. Si cette propriété n'est pas définie, Godot donnera le focus au Control le plus proche à droite de celui-ci.
NodePath focus_neighbor_top = NodePath("") 🔗
Indique à Godot à quel nœud il devrait donner le focus si l'utilisateur appuie sur la flèche haut sur le clavier ou haut sur une manette par défaut. Vous pouvez modifier la touche en éditant l'action d'entrée ProjectSettings.input/ui_up. Le nœud doit être un Control. Si cette propriété n'est pas définie, Godot donnera le focus au Control le plus proche au-dessus de celui-ci.
NodePath focus_next = NodePath("") 🔗
Indique à Godot à quel nœud il devrait donner le focus si l'utilisateur appuie sur Tab sur un clavier par défaut. Vous pouvez modifier la touche en éditant l'action d'entrée ProjectSettings.input/ui_focus_next.
Si cette propriété n'est pas définie, Godot choisira la « meilleure solution » basée sur les nœuds environnants dans l'arborescence.
NodePath focus_previous = NodePath("") 🔗
Indique à Godot à quel nœud il devrait donner le focus si l'utilisateur appuie sur Shift+Tab sur un clavier par défaut. Vous pouvez modifier la touche en éditant l'action d'entrée ProjectSettings.input/ui_focus_prev.
Si cette propriété n'est pas définie, Godot choisira la « meilleure solution » basée sur les nœuds environnants dans l'arborescence.
Vector2 get_global_position()
La position globale du nœud, par rapport au monde (généralement par rapport au CanvasLayer).
GrowDirection grow_horizontal = 1 🔗
void set_h_grow_direction(value: GrowDirection)
GrowDirection get_h_grow_direction()
Control la direction sur l'axe horizontal selon lequel le contrôle doit croître si sa taille minimale horizontale est modifiée pour être supérieure à sa taille actuelle, car le contrôle doit toujours avoir au moins sa taille minimale.
GrowDirection grow_vertical = 1 🔗
void set_v_grow_direction(value: GrowDirection)
GrowDirection get_v_grow_direction()
Control la direction sur l'axe vertical selon lequel le contrôle doit croître si sa taille minimale verticale est changée pour être supérieure à sa taille actuelle, car le contrôle doit toujours avoir au moins sa taille minimale.
LayoutDirection layout_direction = 0 🔗
void set_layout_direction(value: LayoutDirection)
LayoutDirection get_layout_direction()
Contrôle la direction de mise en page et la direction d'écriture du texte. Les mises en page de droite à gauche sont nécessaires pour certaines langues (par exemple, arabe et hébreu). Voir aussi is_layout_rtl().
bool localize_numeral_system = true 🔗
Si true, convertit automatiquement les numéros de ligne de code, les indices de liste, les valeurs de SpinBox et de ProgressBar de l'arabe occidental (0..9) aux systèmes numériques utilisés dans la langue actuelle.
Note : Les nombres dans le texte ne sont pas automatiquement convertis, cela peut être fait manuellement, en utilisant TextServer.format_number().
MouseBehaviorRecursive mouse_behavior_recursive = 0 🔗
void set_mouse_behavior_recursive(value: MouseBehaviorRecursive)
MouseBehaviorRecursive get_mouse_behavior_recursive()
Détermine quels contrôles peuvent recevoir les entrées de la souris ensemble avec mouse_filter. Voir get_mouse_filter_with_override(). Comme le comportement par défaut est MOUSE_BEHAVIOR_INHERITED, cela peut être utilisé pour empêcher tous les contrôles enfants de recevoir les entrées de la souris.
CursorShape mouse_default_cursor_shape = 0 🔗
void set_default_cursor_shape(value: CursorShape)
CursorShape get_default_cursor_shape()
La forme par défaut du curseur pour ce contrôle. Utile pour les greffons de Godot et applications ou jeux qui utilisent les curseurs de souris du système.
Note : Sur Linux, les formes peuvent varier selon le thème du curseur du système.
MouseFilter mouse_filter = 0 🔗
void set_mouse_filter(value: MouseFilter)
MouseFilter get_mouse_filter()
Détermine quels contrôles pourront recevoir les événements d'entrée de bouton de la souris via _gui_input() et les signaux mouse_entered, et mouse_exited. Détermine également comment ces événements devraient être propagés. Voir les constantes pour apprendre ce que chacune fait. Utilisez get_mouse_filter_with_override() pour déterminer si un contrôle peut recevoir l'entrée de la souris, puisque mouse_behavior_recursive l'affecte également.
bool mouse_force_pass_scroll_events = true 🔗
Lorsque activé, les événements de la molette de défilement traités par _gui_input() seront passés au contrôle parent même si mouse_filter est défini à MOUSE_FILTER_STOP.
Vous devriez le désactiver sur la racine de votre interface utilisateur si vous ne voulez pas que les événements de défilement aillent dans le traitement de Node._unhandled_input().
Note : Parce que cette propriété vaut par défaut true, cela permet aux conteneurs défilables imbriqués de fonctionner directement.
Distance entre le bord du bas du nœud et son contrôle parent, basé sur anchor_bottom.
Les décalages sont souvent contrôlés par un ou plusieurs nœuds Container parents, de sorte que vous ne devriez pas les modifier manuellement si votre nœud est un enfant direct d'un Container. Les décalages se mettent à jour automatiquement lorsque vous déplacez ou redimensionnez le nœud.
Distance entre le bord gauche du nœud et son contrôle parent, basé sur anchor_left.
Les décalages sont souvent contrôlés par un ou plusieurs nœuds Container parents, de sorte que vous ne devriez pas les modifier manuellement si votre nœud est un enfant direct d'un Container. Les décalages se mettent à jour automatiquement lorsque vous déplacez ou redimensionnez le nœud.
Distance entre le bord droit du nœud et son contrôle parent, basé sur anchor_right.
Les décalages sont souvent contrôlés par un ou plusieurs nœuds Container parents, de sorte que vous ne devriez pas les modifier manuellement si votre nœud est un enfant direct d'un Container. Les décalages se mettent à jour automatiquement lorsque vous déplacez ou redimensionnez le nœud.
Distance entre le bord du haut du nœud et son contrôle parent, basé sur anchor_top.
Les décalages sont souvent contrôlés par un ou plusieurs nœuds Container parents, de sorte que vous ne devriez pas les modifier manuellement si votre nœud est un enfant direct d'un Container. Les décalages se mettent à jour automatiquement lorsque vous déplacez ou redimensionnez le nœud.
bool offset_transform_enabled = false 🔗
If true, applies all offset transform properties. Otherwise, no offset transform is applied and the properties have no effect.
Vector2 offset_transform_pivot = Vector2(0, 0) 🔗
Pivot used by offset_transform_rotation and offset_transform_scale in absolute units.
The final pivot position is the combined value of this property and offset_transform_pivot_ratio.
Has no effect unless offset_transform_enabled is true.
Vector2 offset_transform_pivot_ratio = Vector2(0.5, 0.5) 🔗
Same as offset_transform_pivot but expressed in units relative to the Control size where Vector2(0, 0) is the top-left corner of this control, and Vector2(1, 1) is its bottom-right corner.
The final pivot position is the combined value of this property and offset_transform_pivot.
Has no effect unless offset_transform_enabled is true.
Vector2 offset_transform_position = Vector2(0, 0) 🔗
Position offset in absolute units. The final offset is the combined value of this property and offset_transform_position_ratio.
Has no effect unless offset_transform_enabled is true.
Vector2 offset_transform_position_ratio = Vector2(0, 0) 🔗
void set_offset_transform_position_ratio(value: Vector2)
Vector2 get_offset_transform_position_ratio()
Same as offset_transform_position but expressed in units relative to the Control size where Vector2(0, 0) is the top-left corner of this control, and Vector2(1, 1) is its bottom-right corner.
The final offset is the combined value of this property and offset_transform_position.
Has no effect unless offset_transform_enabled is true.
float offset_transform_rotation = 0.0 🔗
Rotation offset. The rotation pivot is defined by offset_transform_pivot and offset_transform_pivot_ratio.
Has no effect unless offset_transform_enabled is true.
Vector2 offset_transform_scale = Vector2(1, 1) 🔗
Scale offset. The scale pivot is defined by offset_transform_pivot and offset_transform_pivot_ratio.
Has no effect unless offset_transform_enabled is true.
bool offset_transform_visual_only = true 🔗
If true, the offset transforms is only applied visually and does not affect input. In other words, this Control will still receive input events at its original location before the offset transform is applied.
If false, the entire transform of this Control is affected and input events will register where the Control is visually.
Has no effect unless offset_transform_enabled is true.
Vector2 pivot_offset = Vector2(0, 0) 🔗
By default, the node's pivot is its top-left corner. When you change its rotation or scale, it will rotate or scale around this pivot.
The actual offset is the combined value of this property and pivot_offset_ratio.
Vector2 pivot_offset_ratio = Vector2(0, 0) 🔗
Same as pivot_offset, but expressed as uniform vector, where Vector2(0, 0) is the top-left corner of this control, and Vector2(1, 1) is its bottom-right corner. Set this property to Vector2(0.5, 0.5) to pivot around this control's center.
The actual offset is the combined value of this property and pivot_offset.
Vector2 position = Vector2(0, 0) 🔗
Vector2 get_position()
La position du nœud, par rapport au nœud le contenant. Elle correspond au coin supérieur gauche du rectangle. La propriété n'est pas affectée par pivot_offset.
bool propagate_maximum_size = false 🔗
If true, this Control's children will use the value returned by get_combined_maximum_size() in their own size calculations.
La rotation du nœud autour de son pivot, en radians. Voir pivot_offset pour modifier la position du pivot.
Note : Cette propriété est modifiée en degrés dans l'inspecteur. Si vous voulez utiliser des degrés dans un script, utilisez rotation_degrees.
Propriété d'aide pour accéder à la rotation en degrés au lieu de radians.
Vector2 scale = Vector2(1, 1) 🔗
L'échelle du nœud, relative à size. Changez cette propriété pour changer l'échelle du nœud autour de pivot_offset. L'info-bulle du Control sera également échelonnée en fonction de cette valeur.
Note : Cette propriété est principalement destinée à être utilisée pour des animations. Pour supporter plusieurs résolutions dans votre projet, utilisez un mode d'étirement approprié comme décrit dans la documentation au lieu de dimensionner chaque Control individuellement.
Note: FontFile.oversampling ne prend pas la scale du Control en compte. Cela signifie que l'agrandissement/rétrécissement causera un aspect flou et pixelisé aux polices bitmap et des polices dynamiques rasterisées (non-MSDF). Pour garantir que le texte reste net indépendamment de l'échelle, vous pouvez activer le rendu de police MSDF en activant ProjectSettings.gui/theme/default_font_multichannel_signed_distance_field (s'applique uniquement à la police du projet par défaut), ou en activant Champ de Distance Signé Multicanal dans les options d'import d'une DynamicFont pour les polices personnalisées. Sur les polices système, SystemFont.multichannel_signed_distance_field peut être activé dans l'inspecteur.
Note : Si le nœud Control est un enfant d'un nœud Container, l'échelle sera réinitialisée à Vector2(1, 1) lorsque la scène est instanciée. Pour définir l'échelle du Control lors de son instanciation, attendez une trame avec await get_tree().process_frame puis définissez sa propriété scale.
Le Node qui doit être un parent du Control ayant le focus pour que le raccourci soit activé. Si null, le raccourci peut être activé lorsque n'importe quel contrôle a le focus (un raccourci global). Cela permet aux raccourcis d'être acceptés seulement lorsque l'utilisateur a le focus sur une zone précise de l'interface.
Vector2 size = Vector2(0, 0) 🔗
Vector2 get_size()
La taille du rectangle délimitant du nœud, dans le système de coordonnées du nœud. Les nœuds Container mettent à jour cette propriété automatiquement.
BitField[SizeFlags] size_flags_horizontal = 1 🔗
Signale au Container parent qu'il devrait redimensionner et placer le nœud sur l'axe X. Utilisez une combinaison des constantes SizeFlags pour changer les drapeaux. Regardez les constantes pour apprendre ce que chacune fait.
float size_flags_stretch_ratio = 1.0 🔗
Si le nœud et au moins un de ses voisins utilisent le drapeau de taille SIZE_EXPAND, le Container parent le laissera prendre plus ou moins d'espace selon cette propriété. Si ce nœud a un rapport d'étirement de 2 et son voisin un rapport de 1, ce nœud prendra les deux tiers de l'espace disponible.
BitField[SizeFlags] size_flags_vertical = 1 🔗
Signale au Container parent qu'il devrait redimensionner et placer le nœud sur l'axe Y. Utilisez une combinaison des constantes SizeFlags pour changer les drapeaux. Regardez les constantes pour apprendre ce que chacune fait.
La ressource Theme que ce nœud et tous ses enfants Control et Window utilisent. Si un nœud enfant a son propre ensemble de ressources Theme, les éléments de thème sont fusionnés avec les définitions de l'enfant ayant une priorité plus élevée.
Note : Les styles de Window n'auront aucun effet à moins que la fenêtre ne soit intégrée.
StringName theme_type_variation = &"" 🔗
void set_theme_type_variation(value: StringName)
StringName get_theme_type_variation()
Le nom d'une variation de type d'un thème utilisée par ce Control pour rechercher ses propres éléments de thème. Lorsque vide, le nom de classe du nœud est utilisé (par exemple Button pour le contrôle Button), ainsi que les noms de classe de toutes les classes parentes (dans l'ordre d'héritage).
Lorsque définie, cette propriété donne la plus haute priorité au type du nom spécifié. Ce type peut ensuite étendre un autre type, formant une chaîne de dépendances. Voir Theme.set_type_variation(). Si l'élément de thème n'est pas trouvé en utilisant ce type ou ses types de base, la recherche se replie alors sur les noms de classe.
Note : Pour rechercher les propres éléments d'un Control, utilisez les diverses méthodes get_theme_* sans spécifier theme_type.
Note : Les éléments de thème sont recherchés dans l'ordre de l'arborescence, depuis la branche jusqu'à la racine, où chaque nœud Control est vérifié suivant sa propriété theme. Le premier résultat trouvé sur n'importe quel type ou classe est renvoyé. Le thème du projet et celui par défaut sont vérifiés en dernier.
AutoTranslateMode tooltip_auto_translate_mode = 0 🔗
void set_tooltip_auto_translate_mode(value: AutoTranslateMode)
AutoTranslateMode get_tooltip_auto_translate_mode()
Définit si le texte de l'info-bulle doit automatiquement changer à sa version traduite en fonction de la langue actuelle. Utilise le même mode de traduction automatique que ce contrôle lorsque défini à Node.AUTO_TRANSLATE_MODE_INHERIT.
Note : Les info-bulles personnalisées utilisant _make_custom_tooltip() n'utilisent pas ce mode de traduction automatique automatiquement.
Le texte de l'info-bulle par défaut. L'info-bulle apparaît lorsque le curseur de la souris reste sur ce contrôle durant quelques instants, à condition que la propriété mouse_filter ne vaille pas MOUSE_FILTER_IGNORE. Vous pouvez modifier le temps nécessaire avant que l'info-bulle n'apparaisse avec le paramètre ProjectSettings.gui/timers/tooltip_delay_sec.
Cette chaîne est la valeur de renvoi par défaut de get_tooltip(). Redéfinissez _get_tooltip() pour générer le texte de l'info-bulle dynamiquement. Redéfinissez _make_custom_tooltip() pour personnaliser l'interface et le comportement de l'info-bulle.
La popup de l'info-bulle utilisera soit l'implémentation par défaut, soit une que vous pouvez personnaliser en redéfinissant _make_custom_tooltip(). L'info-bulle par défaut comprend un PopupPanel et un Label dont les propriétés de thème peuvent être personnalisées en utilisant des méthodes de Theme pour "TooltipPanel" et "TooltipLabel" respectivement. Par exemple :
var style_box = StyleBoxFlat.new()
style_box.set_bg_color(Color(1, 1, 0))
style_box.set_border_width_all(2)
# On part du principe ici que la propriété `theme` a déjà été assignée avec un Theme personnalisé.
theme.set_stylebox("panel", "TooltipPanel", style_box)
theme.set_color("font_color", "TooltipLabel", Color(0, 1, 1))
var styleBox = new StyleBoxFlat();
styleBox.SetBgColor(new Color(1, 1, 0));
styleBox.SetBorderWidthAll(2);
// On part du principe ici que la propriété `Theme` a déjà été assignée avec un Theme personnalisé.
Theme.SetStyleBox("panel", "TooltipPanel", styleBox);
Theme.SetColor("font_color", "TooltipLabel", new Color(0, 1, 1));
StringName translation_context = &"" 🔗
void set_translation_context(value: StringName)
StringName get_translation_context()
The translation context used when translating this control's displayed text, if it has any. Also used when generating translation templates.
Descriptions des méthodes
String _accessibility_get_contextual_info() virtual const 🔗
Renvoie la description des raccourcis clavier et des autres aides contextuelles pour ce contrôle.
bool _can_drop_data(at_position: Vector2, data: Variant) virtual const 🔗
Godot appelle cette méthode pour vérifier si les data de la méthode _get_drag_data() d'un contrôle peuvent être déposées à la position at_position. at_position est locale à ce contrôle.
Cette méthode ne devrait être utilisée uniquement que pour tester les données. Traitez les données dans _drop_data().
Note : Si le glissement a été lancé par un raccourci clavier ou accessibility_drag(), at_position est définie à Vector2.INF, et la position de l'objet/texte actuellement sélectionné doit être utilisée comme position de dépôt.
func _can_drop_data(position, data):
# Vérifiez la position si c'est important pour vous
# Sinon, vérifiez juste les données
return typeof(data) == TYPE_DICTIONARY and data.has("attendu")
public override bool _CanDropData(Vector2 atPosition, Variant data)
{
// Vérifiez la position si c'est important pour vous
// Sinon, vérifiez juste les données
return data.VariantType == Variant.Type.Dictionary && data.AsGodotDictionary().ContainsKey("attendu");
}
void _drop_data(at_position: Vector2, data: Variant) virtual 🔗
Godot appelle cette méthode pour vous transmettre les data du résultat de _get_drag_data() d'un contrôle. Godot appelle d'abord _can_drop_data() pour vérifier si data est autorisé à être déposé à la position at_position où at_position est locale à ce contrôle.
Note : Si le glissement a été lancé par un raccourci clavier ou accessibility_drag(), at_position est définie à Vector2.INF, et la position de l'objet/texte actuellement sélectionné doit être utilisée comme position de dépôt.
func _can_drop_data(position, data):
return typeof(data) == TYPE_DICTIONARY and data.has("couleur")
func _drop_data(position, data):
var color = data["couleur"]
public override bool _CanDropData(Vector2 atPosition, Variant data)
{
return data.VariantType == Variant.Type.Dictionary && data.AsGodotDictionary().ContainsKey("couleur");
}
public override void _DropData(Vector2 atPosition, Variant data)
{
Color color = data.AsGodotDictionary()["couleur"].AsColor();
}
String _get_accessibility_container_name(node: Node) virtual const 🔗
Redéfinissez cette méthode pour renvoyer une description facilement lisible de la position du nœud enfant node dans le conteneur personnalisé, ajouté à accessibility_name.
int _get_cursor_shape(at_position: Vector2) virtual const 🔗
Virtual method to be implemented by the user. Returns the cursor shape for the position at_position in the control's local coordinates, which will typically be used while hovering over this control. See get_cursor_shape().
If not overridden, defaults to mouse_default_cursor_shape.
Variant _get_drag_data(at_position: Vector2) virtual 🔗
Godot appelle cette méthode pour obtenir des données qui peuvent être glissées et déposées sur des contrôles qui attendent des données de glisser-déposer. Renvoie null s'il n'y a pas de données à glisser. Les contrôles qui veulent recevoir des données de glisser-déposer doivent implémenter _can_drop_data() et _drop_data(). at_position est locale à ce contrôle. Le glissement peut être forcé avec force_drag().
Un aperçu suivant la souris représentant les données peut être défini avec set_drag_preview(). L'appel à cette méthode est un bon moment définir cet aperçu.
Note : Si le glissement a été lancé par un raccourci clavier ou accessibility_drag(), at_position est définie à Vector2.INF, et la position de l'objet/texte actuellement sélectionné doit être utilisée comme position de dépôt.
func _get_drag_data(position):
var mesdonnees = creer_donnees() # Ceci est votre méthode personnalisées générant les données du glissement.
set_drag_preview(creer_apercu(mesdonnees)) # Ceci est votre méthode personnalisée générant l'aperçu des données du glissement.
return mesdonnees
public override Variant _GetDragData(Vector2 atPosition)
{
var mesDonnees = CreerDonnees(); // Ceci est votre méthode personnalisées générant les données du glissement.
SetDragPreview(CreerApercu(mesDonnees)); // Ceci est votre méthode personnalisée générant l'aperçu des données du glissement.
return mesDonnees;
}
Vector2 _get_maximum_size() virtual const 🔗
Virtual method to be implemented by the user. Returns the maximum size for this control. Alternative to custom_maximum_size for controlling maximum size via code. The actual maximum size will be the max value of these two (in each axis separately).
If not overridden, defaults to Vector2.ZERO.
Note: This method will not be called when the script is attached to a Control node that already overrides its maximum size (e.g. ScrollContainer).
Note: It is recommended to use get_bound_minimum_size() instead of get_combined_minimum_size() when implementing this method, as the former respects maximum size limits when calculating the minimum size, while the latter does not.
Vector2 _get_minimum_size() virtual const 🔗
Méthode virtuelle à implémenter par l'utilisateur. Renvoie la taille minimale de ce contrôle. Cette taille peut aussi être contrôlée avec custom_minimum_size via le code. L'actuelle taille minimale sera le maximum de ces deux valeurs (sur chaque axe séparément).
Si non redéfinie, la valeur par défaut est Vector2.ZERO.
Note : Cette méthode n'est pas appelée quand le script est attaché à un nœud Control qui définit depuis lui-même sa taille minimale (ex. Label, Button, PanelContainer, etc.). Elle ne peut être utilisée qu'avec les éléments d'interface les plus basiques, comme les Control, Container, Panel, etc.
String _get_tooltip(at_position: Vector2) virtual const 🔗
Virtual method to be implemented by the user. Returns the tooltip text for the position at_position in the control's local coordinates, which will typically appear when the cursor is resting over this control. See get_tooltip().
Note: If this method returns an empty String and _make_custom_tooltip() is not overridden, no tooltip is displayed.
AutoTranslateMode _get_tooltip_auto_translate_mode_at(at_position: Vector2) virtual const 🔗
Return the auto-translation mode at the given at_position. If not implemented, the tooltip_auto_translate_mode property will be used instead.
void _gui_input(event: InputEvent) virtual 🔗
Méthode virtuelle à implémenter par l'utilisateur. Redéfinissez cette méthode pour gérer et accepter des entrées sur des éléments d'interface utilisateur. Voir aussi accept_event().
Exemple : Cliquer sur un contrôle pour afficher un message :
func _gui_input(event):
if event is InputEventMouseButton:
if event.button_index == MOUSE_BUTTON_LEFT and event.pressed:
print("J'ai été cliqué ! :D")
public override void _GuiInput(InputEvent @event)
{
if (@event is InputEventMouseButton mb)
{
if (mb.ButtonIndex == MouseButton.Left && mb.Pressed)
{
GD.Print("J'ai été cliqué ! :D");
}
}
}
Si l'évènement event hérite de InputEventMouse, cette méthode ne sera pas appelée lorsque :
le mouse_filter du contrôle est défini à MOUSE_FILTER_IGNORE ;
le contrôle est recouvert par un autre Control, qui n'a pas mouse_filter défini à MOUSE_FILTER_IGNORE ;
le parent de ce contrôle a mouse_filter défini à MOUSE_FILTER_STOP ou a accepté l'événement ;
le parent du contrôle a clip_contents activé et la position de
eventest en dehors du rectangle du parent;la position d'
eventest en dehors du contrôle (voir _has_point()).
Note : La position d'event est relative à l'origine du contrôle.
bool _has_point(point: Vector2) virtual const 🔗
Virtual method to be implemented by the user. Returns whether the given point is inside this control.
If not overridden, default behavior is checking if the point is within the control's Rect.
Note: If you want to check if a point is inside the control, you can use Rect2(Vector2.ZERO, size).has_point(point).
Object _make_custom_tooltip(for_text: String) virtual const 🔗
Virtual method to be implemented by the user. Returns a Control node that should be used as a tooltip instead of the default one. for_text is the return value of get_tooltip().
The returned node must be of type Control or Control-derived. It can have child nodes of any type. It is freed when the tooltip disappears, so make sure you always provide a new instance (if you want to use a pre-existing node from your scene tree, you can duplicate it and pass the duplicated instance). When null or a non-Control node is returned, the default tooltip will be used instead.
The returned node will be added as child to a PopupPanel, so you should only provide the contents of that panel. That PopupPanel can be themed using Theme.set_stylebox() for the type "TooltipPanel" (see tooltip_text for an example).
Note: The tooltip is shrunk to minimal size. If you want to ensure it's fully visible, you might want to set its custom_minimum_size to some non-zero value.
Note: The node (and any relevant children) should have their CanvasItem.visible set to true when returned, otherwise, the viewport that instantiates it will not be able to calculate its minimum size reliably.
Note: If overridden, this method is called even if get_tooltip() returns an empty string. When this happens with the default tooltip, it is not displayed. To copy this behavior, return null in this method when for_text is empty.
Example: Use a constructed node as a tooltip:
func _make_custom_tooltip(for_text):
var label = Label.new()
label.text = for_text
return label
public override Control _MakeCustomTooltip(string forText)
{
var label = new Label();
label.Text = forText;
return label;
}
Example: Use a scene instance as a tooltip:
func _make_custom_tooltip(for_text):
var tooltip = preload("res://some_tooltip_scene.tscn").instantiate()
tooltip.get_node("Label").text = for_text
return tooltip
public override Control _MakeCustomTooltip(string forText)
{
Node tooltip = ResourceLoader.Load<PackedScene>("res://some_tooltip_scene.tscn").Instantiate();
tooltip.GetNode<Label>("Label").Text = forText;
return tooltip;
}
Array[Vector3i] _structured_text_parser(args: Array, text: String) virtual const 🔗
Fonction de redéfinition de l'algorithme BiDi définie par l'utilisateur.
Renvoie un Array de Vector3i de plages de texte et directions de base de texte, dans l'ordre gauche à droite. Les plages devraient couvrir le texte source complet text sans chevauchements. L'algorithme BiDi sera utilisé sur chaque plage séparément.
void accept_event() 🔗
Marque un événement d'entrée comme traité. Une fois un événement accepté, il arrête de se propager, même aux nœuds écoutant Node._unhandled_input() ou Node._unhandled_key_input().
Note : Cela n'affecte pas les méthodes dans Input, seulement la façon dont les événements sont propagés.
void accessibility_drag() 🔗
Commence une opération de glisser-déposer sans utiliser de souris.
void accessibility_drop() 🔗
Termine une opération de glisser-déposer sans utiliser de souris.
void add_theme_color_override(name: StringName, color: Color) 🔗
Crée une redéfinition locale pour une Color de thème nommée name. Les redéfinitions locales ont toujours la priorité lors de la récupération d'éléments de thème pour le contrôle. Une redéfinie peut être retirée avec remove_theme_color_override().
Voir aussi get_theme_color().
Exemple : Redéfinir la couleur d'un Label et la réinitialiser plus tard :
# Compte tenu du nœud enfant Label "MonLabel", remplace sa couleur de police par une valeur personnalisée.
$MonLabel.add_theme_color_override("font_color", Color(1, 0.5, 0))
# Réinitialise la couleur de police du Label enfant.
$MonLabel.remove_theme_color_override("font_color")
# Alternativement, elle peut être redéfinie avec la valeur par défaut du type Label.
$MonLabel.add_theme_color_override("font_color", get_theme_color("font_color", "Label"))
// Compte tenu du nœud enfant Label "MonLabel", remplace sa couleur de police par une valeur personnalisée.
GetNode<Label>("MonLabel").AddThemeColorOverride("font_color", new Color(1, 0.5f, 0));
// Réinitialise la couleur de police du Label enfant.
GetNode<Label>("MonLabel").RemoveThemeColorOverride("font_color");
// Alternativement, elle peut être redéfinie avec la valeur par défaut du type Label.
GetNode<Label>("MonLabel").AddThemeColorOverride("font_color", GetThemeColor("font_color", "Label"));
void add_theme_constant_override(name: StringName, constant: int) 🔗
Crée une redéfinition locale pour une constante de thème nommée name. Les redéfinitions locales ont toujours la priorité lors de la récupération des éléments de thème pour le contrôle. Une surcharge peut être supprimée avec la méthode remove_theme_constant_override().
Voir aussi get_theme_constant().
void add_theme_font_override(name: StringName, font: Font) 🔗
Crée une redéfinition locale pour une Font de thème nommée name. Les redéfinitions locales ont toujours la priorité lors de la récupération des éléments de thème pour le contrôle. Une redéfinition peut être supprimée avec la valeur remove_theme_font_override().
Voir aussi get_theme_font().
void add_theme_font_size_override(name: StringName, font_size: int) 🔗
Crée une redéfinition locale pour une taille de police de thème nommée name. Les redéfinitions locales ont toujours la priorité lors de la récupération des éléments de thème pour le contrôle. Une redéfinition peut être supprimée avec la valeur remove_theme_font_size_override().
Voir aussi get_theme_font_size().
void add_theme_icon_override(name: StringName, texture: Texture2D) 🔗
Crée une redéfinition locale pour une icône de thème nommée name. Les redéfinitions locales ont toujours la priorité lors de la récupération des éléments de thème pour le contrôle. Une redéfinition peut être supprimée avec la valeur remove_theme_icon_override().
Voir aussi get_theme_icon().
void add_theme_stylebox_override(name: StringName, stylebox: StyleBox) 🔗
Crée une redéfinition locale pour une StyleBox de thème nommée name. Les redéfinitions locales ont toujours la priorité lors de la récupération d'éléments de thème pour le contrôle. Une redéfinie peut être retirée avec remove_theme_stylebox_override().
Voir aussi get_theme_stylebox().
Exemple : Modifier une propriété dans une StyleBox en la dupliquant :
# Le code ci-dessous part du principe que le nœud enfant "MonBouton" a une StyleBoxFlat qui lui est assignée.
# Les ressources sont partagées entre les instances, il est donc nécessaire de les dupliquer
# pour éviter que les modifications ne se répercutent sur tous les autres boutons.
var nouvelle_stylebox_normal = $MyButton.get_stylebox("normal").duplicate()
nouvelle_stylebox_normal.border_width_top = 3
nouvelle_stylebox_normal.border_color = Color(0, 1, 0.5)
$MonBouton.add_stylebox_override("normal", nouvelle_stylebox_normal)
# Retirer la redéfinition de la stylebox.
$MonBouton.add_stylebox_override("normal", null)
// Le code ci-dessous part du principe que le nœud enfant "MonBouton" a une StyleBoxFlat qui lui est assignée.
// Les ressources sont partagées entre les instances, il est donc nécessaire de les dupliquer
// pour éviter que les modifications ne se répercutent sur tous les autres boutons.
StyleBoxFlat nouvelleStyleboxNomal = GetNode<Button>("MonBouton").GetThemeStylebox("normal").Duplicate() as StyleBoxFlat;
nouvelleStyleboxNomal.BorderWidthTop = 3;
nouvelleStyleboxNomal.BorderColor = new Color(0, 1, 0.5f);
GetNode<Button>("MonBouton").AddThemeStyleboxOverride("normal", nouvelleStyleboxNomal);
// Retirer la redéfinition de la stylebox.
GetNode<Button>("MonBouton").RemoveThemeStyleboxOverride("normal");
void begin_bulk_theme_override() 🔗
Empêche les méthodes *_theme_*_override d'émettre NOTIFICATION_THEME_CHANGED jusqu'à ce que end_bulk_theme_override() soit appelée.
void end_bulk_theme_override() 🔗
Termine une mise à jour de masse de redéfinition du thème. Voir begin_bulk_theme_override().
Control find_next_valid_focus() const 🔗
Cherche le prochain (en-dessous dans l'arborescence) Control qui peut prendre le focus.
Control find_prev_valid_focus() const 🔗
Trouve (et renvoie) le Control précédent (au-dessus dans l'arbre) qui peut recevoir le focus.
Control find_valid_focus_neighbor(side: Side) const 🔗
Trouve le prochain Control qui peut recevoir le focus du côté Side spécifié.
Note : Ceci est différent de get_focus_neighbor(), qui renvoie le chemin d'un voisin de focus spécifié.
void force_drag(data: Variant, preview: Control) 🔗
Force le glissement et contourne _get_drag_data() et set_drag_preview() en passant data et preview. Le glissement va commencer même si la souris n'est ni sur, ni appuyée sur ce contrôle.
Les méthodes _can_drop_data() et _drop_data() doivent être implémentées pour les contrôles qui veulent recevoir des données de glissement.
float get_anchor(side: Side) const 🔗
Renvoie l'ancre du côté Side spécifié. Une méthode getter pour anchor_bottom, anchor_left, anchor_right et anchor_top.
Renvoie offset_left et offset_top. Voir aussi position.
Vector2 get_bound_minimum_size() const 🔗
Returns the bound value of get_combined_minimum_size() by get_combined_maximum_size().
This value is the true minimum size of the container, as the maximum size has priority over the minimum size.
For example, if the combined minimum size is (100, 100) and the combined maximum size is (50, 150), the bound minimum size will be (50, 100).
Vector2 get_combined_maximum_size() const 🔗
Returns the combined maximum size from custom_maximum_size and get_maximum_size(), as well as the custom_maximum_size of this node's parent if it is a Control node with propagate_maximum_size set to true.
Vector2 get_combined_minimum_size() const 🔗
Returns the combined minimum size from custom_minimum_size and get_minimum_size().
Vector2 get_combined_pivot_offset() const 🔗
Returns the combined value of pivot_offset and pivot_offset_ratio, in pixels. The ratio is multiplied by the control's size.
CursorShape get_cursor_shape(at_position: Vector2 = Vector2(0, 0)) const 🔗
Returns the mouse cursor shape for this control when hovered over at_position in local coordinates. For most controls, this is the same as mouse_default_cursor_shape, but some built-in controls implement more complex logic.
You can override _get_cursor_shape() to implement custom behavior for this method.
Renvoie offset_right et offset_bottom.
FocusMode get_focus_mode_with_override() const 🔗
Renvoie le focus_mode, mais prend en compte le focus_behavior_recursive. Si focus_behavior_recursive est défini à FOCUS_BEHAVIOR_DISABLED, ou est défini à FOCUS_BEHAVIOR_INHERITED et son ancêtre est défini à FOCUS_BEHAVIOR_DISABLED, alors ceci renvoie FOCUS_NONE.
NodePath get_focus_neighbor(side: Side) const 🔗
Renvoie le voisin de focus pour le côte Side spécifié. Une méthode getter pour focus_neighbor_bottom, focus_neighbor_left, focus_neighbor_right et focus_neighbor_top.
Note : Pour trouver le prochain Control sur le Side spécifique, même si un voisin n'est pas assigné, utilisez find_valid_focus_neighbor().
Rect2 get_global_rect() const 🔗
Renvoie la position et la taille du contrôle relativement au canevas le contenant. Voir global_position et size.
Note : Si le nœud lui-même ou tout parent CanvasItem entre le nœud et le canevas ont une rotation ou un cisaillement non par défaut, la taille résultante n'est probablement pas significative.
Note : Définir Viewport.gui_snap_controls_to_pixels à true peut conduire à des erreurs d'arrondi entre le contrôle affiché et le Rect2 renvoyé.
Vector2 get_maximum_size() const 🔗
Returns the maximum size for this control. See custom_maximum_size.
Vector2 get_minimum_size() const 🔗
Renvoie la taille minimale pour ce contrôle. Voir custom_minimum_size.
MouseFilter get_mouse_filter_with_override() const 🔗
Renvoie le mouse_filter, mais prend en compte le mouse_behavior_recursive. Si mouse_behavior_recursive est défini à MOUSE_BEHAVIOR_DISABLED, ou il est défini à MOUSE_BEHAVIOR_INHERITED et son ancêtre est défini à MOUSE_BEHAVIOR_DISABLED, alors cela renvoie MOUSE_FILTER_IGNORE.
float get_offset(offset: Side) const 🔗
Renvoie le décalage pour le côté Side spécifié. Une méthode getter pour offset_bottom, offset_left, offset_right et offset_top.
Vector2 get_parent_area_size() const 🔗
Renvoie la largeur / hauteur occupée dans le contrôle parent.
Control get_parent_control() const 🔗
Renvoie le nœud de contrôle parent.
Renvoie la position et la taille du contrôle dans le système de coordonnées du nœud le contenant. Voir position, scale et size.
Note : Si rotation n'est pas la rotation par défaut, la taille résultante n'est pas significative.
Note : Définir Viewport.gui_snap_controls_to_pixels à true peut conduire à des erreurs d'arrondi entre le contrôle affiché et le Rect2 renvoyé.
Vector2 get_screen_position() const 🔗
Renvoie la position de ce Control dans les coordonnées globales de l'écran (c.-à-d. en tenant compte de la position de la fenêtre). Généralement utile pour les plugins éditeur.
Équivalent à get_screen_transform().origin (voir CanvasItem.get_screen_transform()).
Exemple : Afficher une popup à la position de la souris :
menu_popup.position = get_screen_position() + get_screen_transform().basis_xform(get_local_mouse_position())
# Le code au dessus est équivalent à :
menu_popup.position = get_screen_transform() * get_local_mouse_position()
menu_popup.reset_size()
menu_popup.popup()
Color get_theme_color(name: StringName, theme_type: StringName = &"") const 🔗
Renvoie une Color du premier Theme correspondant dans l'arborescence si ce Theme a un élément de couleur avec le nom name et le type theme_type spécifiés. Si theme_type n'est pas précisé, le nom de classe du contrôle actuel sera utilisé pour le type, ou theme_type_variation si défini. Si le type est un nom de classe, ses classes parentes sont également testées, par ordre d'héritage. Si le type est une variation, ses types de bases sont vérifiés, dans l'ordre des dépendances, et enfin le nom de la classe du contrôle et ses classes parentes sont vérifiées.
Pour le contrôle actuel, ses redéfinitions locales sont considérées en premier (voir add_theme_color_override()), puis son theme assigné. Après le contrôle actuel, chaque contrôle parent et son theme assigné seront pris en considération, les contrôles sans de theme assigné sont ignorés. Si aucune correspondance de Theme n'est trouvée dans l'arborescence, le Theme personnalisé du projet (voir ProjectSettings.gui/theme/custom) et le Theme par défaut seront utilisés (voir ThemeDB).
func _ready():
# Obtenir la couleur de police définie pour la classe du Control actuel, si elle existe.
modulate = get_theme_color("font_color")
# Obtenir la couleur de police définie pour la classe Button.
modulate = get_theme_color("font_color", "Button")
public override void _Ready()
{
// Obtenir la couleur de police définie pour la classe du Control actuel, si elle existe.
Modulate = GetThemeColor("font_color");
// Obtenir la couleur de police définie pour la classe Button.
Modulate = GetThemeColor("font_color", "Button");
}
int get_theme_constant(name: StringName, theme_type: StringName = &"") const 🔗
Renvoie une constante du premier Theme correspondant dans l'arborescence si ce Theme a un élément constant avec le nom name et le type theme_type spécifiés.
Voir get_theme_color() pour plus de détails.
float get_theme_default_base_scale() const 🔗
Renvoie la valeur d'échelle de base par défaut du premier Theme correspondant dans l'arborescence si ce Theme a une valeur Theme.default_base_scale valide.
Voir get_theme_color() pour plus de détails.
Font get_theme_default_font() const 🔗
Renvoie la police par défaut du premier Theme correspondant dans l'arborescence si ce Theme a une valeur Theme.default_font valide.
Voir get_theme_color() pour plus de détails.
int get_theme_default_font_size() const 🔗
Renvoie la taille de police par défaut du premier Theme correspondant dans l'arborescence si ce Theme a une valeur Theme.default_font_size valide.
Voir get_theme_color() pour plus de détails.
Font get_theme_font(name: StringName, theme_type: StringName = &"") const 🔗
Renvoie une Font du premier Theme correspondant dans l'arborescence si ce Theme a un élément de police nommé name et du type de thème theme_type.
Voir get_theme_color() pour plus de détails.
int get_theme_font_size(name: StringName, theme_type: StringName = &"") const 🔗
Renvoie une Font du premier Theme correspondant dans l'arborescence si ce Theme a un élément de taille de police nommé name et du type de thème theme_type.
Voir get_theme_color() pour plus de détails.
Texture2D get_theme_icon(name: StringName, theme_type: StringName = &"") const 🔗
Renvoie une icône du premier Theme correspondant dans l'arborescence si ce Theme a une propriété d'icône nommée name et du type de thème theme_type.
Voir get_theme_color() pour plus de détails.
StyleBox get_theme_stylebox(name: StringName, theme_type: StringName = &"") const 🔗
Renvoie une StyleBox du premier Theme correspondant dans l'arborescence si ce Theme a une propriété de boîte de style nommée name et du type de thème theme_type.
Voir get_theme_color() pour plus de détails.
String get_tooltip(at_position: Vector2 = Vector2(0, 0)) const 🔗
Returns the tooltip text for the position at_position in the control's local coordinates, which will typically appear when the cursor is resting over this control. By default, it returns tooltip_text.
You can override _get_tooltip() to implement custom behavior for this method.
Note: If this method returns an empty String and _make_custom_tooltip() is not overridden, no tooltip is displayed.
void grab_click_focus() 🔗
Crée un InputEventMouseButton qui tente de cliquer sur le contrôle. Si l'événement est reçu, le contrôle reçoit le focus.
func _process(delta):
grab_click_focus() # Lorsque vous cliquez sur un autre contrôle, ce nœud sera cliqué à la place.
public override void _Process(double delta)
{
GrabClickFocus(); // Lorsque vous cliquez sur un autre contrôle, ce nœud sera cliqué à la place.
}
void grab_focus(hide_focus: bool = false) 🔗
Steal the focus from another control and become the focused control (see focus_mode).
If hide_focus is true, the control will not visually show its focused state. Has no effect for LineEdit and TextEdit when ProjectSettings.gui/common/show_focus_state_on_pointer_event is set to Text Input Controls, or for any control when it is set to Always.
Note: Using this method together with Callable.call_deferred() makes it more reliable, especially when called inside Node._ready().
bool has_focus(ignore_hidden_focus: bool = false) const 🔗
Returns true if this is the current focused control. See focus_mode.
If ignore_hidden_focus is true, controls that have their focus hidden will always return false. Hidden focus happens automatically when controls gain focus via mouse input, or manually using grab_focus() with hide_focus set to true.
bool has_theme_color(name: StringName, theme_type: StringName = &"") const 🔗
Renvoie true s'il y a un Theme correspondant dans l'arborescence qui a une propriété de couleur nommée name et du type de thème theme_type.
Voir get_theme_color() pour plus de détails.
bool has_theme_color_override(name: StringName) const 🔗
Renvoie true s'il y a une redéfinition locale pour une Color de thème nommée name dans ce nœud Control.
Voir add_theme_color_override().
bool has_theme_constant(name: StringName, theme_type: StringName = &"") const 🔗
Renvoie true s'il y a un Theme correspondant dans l'arborescence qui a un élément constant avec le nom name et type de thème theme_type spécifiés.
Voir get_theme_color() pour plus de détails.
bool has_theme_constant_override(name: StringName) const 🔗
Renvoie true s'il y a une redéfinition locale pour une constante de thème nommée name dans ce nœud Control.
Voir add_theme_constant_override().
bool has_theme_font(name: StringName, theme_type: StringName = &"") const 🔗
Renvoie true s'il existe un Theme correspondant dans l’arborescence qui a un élément de police nommé name et de type de thème theme_type spécifiés.
Voir get_theme_color() pour plus de détails.
bool has_theme_font_override(name: StringName) const 🔗
Renvoie true s'il y a une redéfinition pour une Font de thème nommée name dans ce nœud Control.
Voir add_theme_font_override().
bool has_theme_font_size(name: StringName, theme_type: StringName = &"") const 🔗
Renvoie true s'il existe un Theme correspondant dans l’arborescence qui a un élément de taille de police avec le nom name et le type de thème theme_type spécifiés.
Voir get_theme_color() pour les détails.
bool has_theme_font_size_override(name: StringName) const 🔗
Renvoie true s'il y a une redéfinition locale pour une taille de police de thème nommée name dans ce nœud Control.
Voir add_theme_font_size_override().
bool has_theme_icon(name: StringName, theme_type: StringName = &"") const 🔗
Renvoie true s'il existe un Theme correspondant dans l’arborescence qui a un élément d'icône nommé name et de type de thème theme_type spécifiés.
Voir get_theme_color() pour plus de détails.
bool has_theme_icon_override(name: StringName) const 🔗
Renvoie true s'il y a une redéfinition locale pour une icône de thème nommée name dans ce nœud Control.
Voir add_theme_icon_override().
bool has_theme_stylebox(name: StringName, theme_type: StringName = &"") const 🔗
Renvoie true s'il existe un Theme correspondant dans l’arborescence qui a un élément de stylebox nommé name et de type de thème theme_type spécifiés.
Voir get_theme_color() pour plus de détails.
bool has_theme_stylebox_override(name: StringName) const 🔗
Renvoie true s'il y a une redéfinition locale pour une StyleBox de thème nommée name dans ce nœud Control.
Voir add_theme_stylebox_override().
bool is_drag_successful() const 🔗
Renvoie true si l'opération de glisser-deposer a réussi. Alternative à Viewport.gui_is_drag_successful().
Généralement utilisé avec Node.NOTIFICATION_DRAG_END.
Renvoie true si la mise en page est de droite à gauche. Voir aussi layout_direction.
void release_focus() 🔗
Relâche le focus. Aucun autre contrôle ne pourra recevoir d'entrées.
void remove_theme_color_override(name: StringName) 🔗
Retire une redéfinition locale pour une Color de thème nommée name ajoutée précédemment par add_theme_color_override() ou via le dock Inspecteur.
void remove_theme_constant_override(name: StringName) 🔗
Supprime une redéfinition locale pour une constante de thème nommée name ajoutée précédemment par add_theme_constant_override() ou via le dock Inspecteur.
void remove_theme_font_override(name: StringName) 🔗
Retire une redéfinition locale pour une Font de thème nommée name ajoutée précédemment par add_theme_font_override() ou via le dock Inspecteur.
void remove_theme_font_size_override(name: StringName) 🔗
Retire une redéfinition locale pour une taille de police de thème nommée name ajoutée précédemment par add_theme_font_size_override() ou via le dock Inspecteur.
void remove_theme_icon_override(name: StringName) 🔗
Retire une redéfinition locale pour une icône de thème nommée name ajoutée précédemment par add_theme_icon_override() ou via le dock Inspecteur.
void remove_theme_stylebox_override(name: StringName) 🔗
Retire une redéfinition locale pour une StyleBox de thème nommée name ajoutée précédemment par add_theme_stylebox_override() ou via le dock Inspecteur.
void reset_size() 🔗
Réinitialise la taille à get_combined_minimum_size(). Ceci équivaut à appeler set_size(Vector2()) (ou toute taille inférieure au minimum).
void set_anchor(side: Side, anchor: float, keep_offset: bool = false, push_opposite_anchor: bool = true) 🔗
Définit l'ancre pour le côté Side spécifié à anchor. Une méthode setter pour anchor_bottom, anchor_left, anchor_right et anchor_top.
Si keep_offset vaut true, les décalages ne seront pas mises à jour après cette opération.
Si push_opposite_anchor vaut true et que l'ancre opposée recouvre cette ancre, l'ancre opposée aura sa valeur redéfinie. Par exemple, lorsque l'ancre gauche est fixée à 1 et que l'ancre droite a une valeur de 0.5, l'ancre droite aura également une valeur de 1. Si push_opposite_anchor valait false, l'ancre gauche aurait alors une valeur de 0.5.
void set_anchor_and_offset(side: Side, anchor: float, offset: float, push_opposite_anchor: bool = false) 🔗
Fonctionne comme set_anchor(), mais au lieu de l'argument keep_offset et de la mise à jour automatique du décalage, elle vous permet de définir le décalage vous-même (voir set_offset()).
void set_anchors_and_offsets_preset(preset: LayoutPreset, resize_mode: LayoutPresetMode = 0, margin: int = 0) 🔗
Définit à la fois le préréglage de l'ancre et le préréglage du décalage. Voir set_anchors_preset() et set_offsets_preset().
void set_anchors_preset(preset: LayoutPreset, keep_offsets: bool = false) 🔗
Définit les ancres à un préréglage preset de l'énumeration LayoutPreset. C'est le code équivalent à l'utilisation du menu Disposition dans l'éditeur 2D.
Si keep_offsets vaut true, la position du contrôle sera également mise à jour.
void set_begin(position: Vector2) 🔗
Définit à la fois offset_left et offset_top. Équivalent à changer position.
void set_drag_forwarding(drag_func: Callable, can_drop_func: Callable, drop_func: Callable) 🔗
Définit les callables donnés à être utilisés au lieu des propres méthodes virtuelles de glisser-déposer du contrôle. Si un callable est vide, sa méthode virtuelle respective est utilisée comme habituellement.
Les arguments pour chaque appelable devraient être exactement les mêmes que leurs méthodes virtuelles respectives, ce qui serait :
drag_funccorrespond à _get_drag_data() et nécessite un Vector2;can_drop_funccorrespond à _can_drop_data() et nécessite à la fois un Vector2 et un Variant;drop_funccorrespond à _drop_data() et nécessite à la fois un Vector2 et un Variant.
void set_drag_preview(control: Control) 🔗
Affiche le contrôle donné comme curseur de la souris. Un bon moment pour appeler cette méthode est dans _get_drag_data(). Le contrôle doit ne pas être dans l'arborescence de la scène. Vous ne devriez pas libérer le contrôle, et vous ne devriez pas garder une référence vers le contrôle en-dehors de la durée du glissement. Il sera supprimé automatiquement après que le glissement soit terminé.
@export var couleur = Color(1, 0, 0, 1)
func _get_drag_data(position):
# Utiliser un contrôle qui n'est pas dans l'arborescence
var cpb = ColorPickerButton.new()
cpb.color = couleur
cpb.rect_size = Vector2(50, 50)
set_drag_preview(cpb)
return couleur
[Export]
private Color _couleur = new Color(1, 0, 0, 1);
public override Variant _GetDragData(Vector2 atPosition)
{
// Utiliser un contrôle qui n'est pas dans l'arborescence
var cpb = new ColorPickerButton();
cpb.Color = _couleur;
cpb.Size = new Vector2(50, 50);
SetDragPreview(cpb);
return _couleur;
}
void set_end(position: Vector2) 🔗
Définit à la fois offset_right et offset_bottom.
void set_focus_neighbor(side: Side, neighbor: NodePath) 🔗
Définit le voisin de focus pour le côté Side spécifié au Control au chemin de nœud neighbor. Une méthode setter pour focus_neighbor_bottom, focus_neighbor_left, focus_neighbor_right et focus_neighbor_top.
void set_global_position(position: Vector2, keep_offsets: bool = false) 🔗
Définit le global_position à la position spécifiée.
Si keep_offsets vaut true, les ancrages de contrôle seront changés à la place des marges.
void set_offset(side: Side, offset: float) 🔗
Définit le décalage pour le côté Side spécifié à offset. Une méthode setter pour offset_bottom, offset_left, offset_right et offset_top.
void set_offsets_preset(preset: LayoutPreset, resize_mode: LayoutPresetMode = 0, margin: int = 0) 🔗
Définit les décalages à un préréglage preset de l'énumeration LayoutPreset. Il s'agit de l'équivalent en code de l'utilisation du menu Disposition dans l'éditeur 2D.
Utilisez le paramètre resize_mode avec des constantes de LayoutPresetMode pour mieux déterminer la taille résultante du Control. La taille constante sera ignorée si elle est utilisée avec des préréglages qui changent la taille, par exemple PRESET_LEFT_WIDE.
Utilisez le paramètre margin pour déterminer l'écart entre le Control et les bords.
void set_position(position: Vector2, keep_offsets: bool = false) 🔗
Défini la position à la position donnée.
Si keep_offsets vaut true, les ancres du contrôle sont mis à jour au lieu des décalages.
void set_size(size: Vector2, keep_offsets: bool = false) 🔗
Définit la taille (voir size).
Si keep_offsets vaut true, les ancres du contrôle sont mis à jour au lieu des décalages.
void update_maximum_size() 🔗
Invalidates the maximum size cache in this node and in parent nodes up to top level. Intended to be used with get_maximum_size() when the return value is changed. Setting custom_maximum_size directly calls this method automatically.
Note: Calling this method also calls update_minimum_size() since the combined minimum size may be affected by the maximum size change.
void update_minimum_size() 🔗
Invalidates the minimum size cache in this node and in parent nodes up to top level. Intended to be used with get_minimum_size() when the return value is changed. Setting custom_minimum_size directly calls this method automatically.
void warp_mouse(position: Vector2) 🔗
Déplace le curseur de la souris vers position, relative à position de ce Control.
Note : warp_mouse() n'est supportée que sous Windows, macOS et Linux. Elle n'a aucun effet sur Android, iOS et Web.