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
Eredita: CanvasItem < Node < Object
Ereditato da: BaseButton, ColorRect, Container, GraphEdit, ItemList, Label, LineEdit, MenuBar, NinePatchRect, Panel, Range, ReferenceRect, RichTextLabel, Separator, TabBar, TextEdit, TextureRect, Tree, VideoStreamPlayer, VirtualJoystick
Classe di base per tutti i controlli della GUI. Adatta la sua posizione e dimensioni in base al suo controllo padre.
Descrizione
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.
Tutorial
Proprietà
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
physics_interpolation_mode |
|
|
|
||
|
||
|
||
|
||
|
||
|
||
|
||
BitField[SizeFlags] |
|
|
|
||
BitField[SizeFlags] |
|
|
|
||
|
||
|
||
|
Metodi
Segnali
focus_entered() 🔗
Emesso quando il nodo ottiene il focus.
focus_exited() 🔗
Emesso quando il nodo perde il focus.
gui_input(event: InputEvent) 🔗
Emesso quando il nodo riceve un InputEvent.
maximum_size_changed() 🔗
Emitted when the node's maximum size changes.
minimum_size_changed() 🔗
Emesso quando le dimensioni minime del nodo cambiano.
mouse_entered() 🔗
Emesso quando il cursore del mouse entra nell'area visibile del controllo (o di qualsiasi controllo figlio), che non è coperta dietro altri controlli o finestre, a condizione che il suo mouse_filter consenta all'evento di raggiungerlo e a prescindere dal fatto che sia attualmente focalizzato o meno.
Nota: CanvasItem.z_index non influisce sul controllo che riceve il segnale.
mouse_exited() 🔗
Emesso quando il cursore del mouse esce dall'area visibile del controllo (o di qualsiasi controllo figlio), che non è coperta dietro altri controlli o finestre, a condizione che il suo mouse_filter consenta all'evento di raggiungerlo e a prescindere dal fatto che sia attualmente focalizzato o meno.
Nota: CanvasItem.z_index non influenza quale Controllo riceve il segnale.
Nota: Se vuoi controllare se il mouse ha davvero lasciato l'area, ignorando tutti i nodi superiori, puoi usare codice come questo:
func _on_mouse_exited():
if not Rect2(Vector2(), size).has_point(get_local_mouse_position()):
# Non sta passando su quest'area.
resized() 🔗
Emesso quando il controllo cambia di dimensioni.
size_flags_changed() 🔗
Emesso quando cambia uno dei flag di dimensione. Vedi size_flags_horizontal e size_flags_vertical.
theme_changed() 🔗
Emesso quando la notifica NOTIFICATION_THEME_CHANGED viene inviata.
Enumerazioni
enum FocusMode: 🔗
FocusMode FOCUS_NONE = 0
Il nodo non può catturare il focus. Da utilizzare con focus_mode.
FocusMode FOCUS_CLICK = 1
Il nodo può catturare il focus solo tramite i clic del mouse. Da utilizzare con focus_mode.
FocusMode FOCUS_ALL = 2
Il nodo può catturare il focus con un clic del mouse, usando le frecce e i tasti Tab sulla tastiera, o usando i pulsanti del D-pad su un gamepad. Da usare con focus_mode.
FocusMode FOCUS_ACCESSIBILITY = 3
Il nodo può catturare il focus solo quando il lettore dello schermo è attivo. Da utilizzare con focus_mode.
enum FocusBehaviorRecursive: 🔗
FocusBehaviorRecursive FOCUS_BEHAVIOR_INHERITED = 0
Eredita il focus_behavior_recursive dal controllo padre. Se nessun controllo padre è presente, è uguale a FOCUS_BEHAVIOR_ENABLED.
FocusBehaviorRecursive FOCUS_BEHAVIOR_DISABLED = 1
Impedisce al controllo di ottenere il focus. get_focus_mode_with_override() restituirà FOCUS_NONE.
FocusBehaviorRecursive FOCUS_BEHAVIOR_ENABLED = 2
Consente al controllo di ottenere il focus, a seconda di focus_mode. Si può utilizzare per ignorare il focus_behavior_recursive del padre. get_focus_mode_with_override() restituirà focus_mode.
enum MouseBehaviorRecursive: 🔗
MouseBehaviorRecursive MOUSE_BEHAVIOR_INHERITED = 0
Eredita il mouse_behavior_recursive dal controllo padre. Se nessun controllo padre è presente, è uguale a MOUSE_BEHAVIOR_ENABLED.
MouseBehaviorRecursive MOUSE_BEHAVIOR_DISABLED = 1
Impedisce al controllo di ricevere gli input del mouse. get_mouse_filter_with_override() restituirà 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
Mostra il cursore del mouse del sistema a forma di freccia quando l'utente passa il mouse sul nodo. Da utilizzare con mouse_default_cursor_shape.
CursorShape CURSOR_IBEAM = 1
Mostra il cursore del mouse del sistema a forma di I del sistema quando l'utente passa il mouse sul nodo. Il puntatore a I ha una forma simile a "I". Indica all'utente che può evidenziare o inserire testo.
CursorShape CURSOR_POINTING_HAND = 2
Mostra il cursore del mouse del sistema a forma di mano che punta quando l'utente passa il mouse sul nodo.
CursorShape CURSOR_CROSS = 3
Mostra il cursore del mouse del sistema a forma di croce quando l'utente passa il mouse sul nodo.
CursorShape CURSOR_WAIT = 4
Mostra il cursore del mouse del sistema di attesa quando l'utente passa il mouse sul nodo. Spesso una clessidra.
CursorShape CURSOR_BUSY = 5
Mostra il cursore del mouse del sistema occupato quando l'utente passa il mouse sul nodo. Spesso una freccia con una piccola clessidra.
CursorShape CURSOR_DRAG = 6
Mostra il cursore del mouse del sistema di trascinamento, spesso un pugno chiuso o un simbolo a croce, quando l'utente passa il mouse sul nodo. Comunica all'utente che sta trascinando un elemento, come un nodo nel pannello di Scena.
CursorShape CURSOR_CAN_DROP = 7
Mostra il cursore del mouse del sistema di rilascio quando l'utente passa il mouse sul nodo. Può essere una mano aperta. Indica all'utente che può rilasciare un oggetto che sta afferrando, come un nodo nel pannello di Scena.
CursorShape CURSOR_FORBIDDEN = 8
Mostra il cursore del mouse del sistema proibito quando l'utente passa il mouse sul nodo. Spesso un cerchio barrato.
CursorShape CURSOR_VSIZE = 9
Mostra il cursore del mouse del sistema per il ridimensionamento verticale quando l'utente passa il mouse sul nodo. Una freccia verticale a due punte. Indica all'utente che può ridimensionare la finestra o il pannello verticalmente.
CursorShape CURSOR_HSIZE = 10
Mostra il cursore del mouse del sistema per il ridimensionamento orizzontale quando l'utente passa il mouse sul nodo. Una freccia orizzontale a due punte. Indica all'utente che può ridimensionare la finestra o il pannello orizzontale.
CursorShape CURSOR_BDIAGSIZE = 11
Mostra il cursore del mouse del sistema per ridimensionare la finestra quando l'utente passa il mouse sul nodo. Il cursore è una freccia a due punte che va dal basso a sinistra all'alto a destra. Indica all'utente che può ridimensionare la finestra o il pannello sia orizzontalmente sia verticalmente.
CursorShape CURSOR_FDIAGSIZE = 12
Mostra il cursore del mouse del sistema per ridimensionare la finestra quando l'utente passa il mouse sul nodo. Il cursore è una freccia a due punte che va dall'alto a sinistra al basso a destra. Indica all'utente che può ridimensionare la finestra o il pannello sia orizzontalmente sia verticalmente.
CursorShape CURSOR_MOVE = 13
Mostra il cursore del mouse del sistema di movimento quando l'utente passa il mouse sul nodo. Mostra 2 frecce a doppia punta a un angolo di 90 gradi. Indica all'utente che può spostare liberamente un elemento dell'interfaccia utente.
CursorShape CURSOR_VSPLIT = 14
Mostra il cursore del mouse del sistema con un separatore verticale quando l'utente passa il mouse sul nodo. Su Windows, è uguale a CURSOR_VSIZE.
CursorShape CURSOR_HSPLIT = 15
Mostra il cursore del mouse del sistema con un separatore orizzontale quando l'utente passa il mouse sul nodo. Su Windows, è uguale a CURSOR_HSIZE.
CursorShape CURSOR_HELP = 16
Mostra il cursore del mouse del sistema di guida quando l'utente passa il mouse sul nodo, un punto interrogativo.
enum LayoutPreset: 🔗
LayoutPreset PRESET_TOP_LEFT = 0
Aggancia tutti e 4 gli ancoraggi in alto a sinistra dei limiti del controllo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_TOP_RIGHT = 1
Aggancia tutti e 4 gli ancoraggi in alto a destra dei limiti del controllo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_BOTTOM_LEFT = 2
Aggancia tutti e 4 gli ancoraggi in basso a sinistra dei limiti del controllo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_BOTTOM_RIGHT = 3
Aggancia tutti e 4 gli ancoraggi in basso a destra dei limiti del controllo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_CENTER_LEFT = 4
Aggancia tutti e 4 gli ancoraggi al centro del bordo sinistro dei limiti del controllo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_CENTER_TOP = 5
Aggancia tutti e 4 gli ancoraggi al centro del bordo superiore dei limiti del controllo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_CENTER_RIGHT = 6
Aggancia tutti e 4 gli ancoraggi al centro del bordo destro dei limiti del controllo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_CENTER_BOTTOM = 7
Aggancia tutti e 4 gli ancoraggi al centro del bordo inferiore dei limiti del controllo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_CENTER = 8
Aggancia tutti e 4 gli ancoraggi al centro dei limiti del controllo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_LEFT_WIDE = 9
Aggancia tutti e 4 gli ancoraggi al lato sinistro del controllo padre. L'offset sinistro diventa relativo al bordo sinistro e l'offset superiore relativo all'angolo in alto a sinistra del nodo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_TOP_WIDE = 10
Aggancia tutti e 4 gli ancoraggi al lato superiore del controllo padre. L'offset sinistro diventa relativo all'angolo superiore sinistro, l'offset superiore relativo al bordo superiore, e l'offset destro relativo all'angolo superiore destro del nodo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_RIGHT_WIDE = 11
Aggancia tutti e 4 gli ancoraggi al lato superiore del controllo padre. L'offset destro diventa relativo al bordo destro e l'offset superiore relativo all'angolo superiore destro del nodo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_BOTTOM_WIDE = 12
Aggancia tutti e 4 gli ancoraggi al lato superiore del controllo padre. L'offset sinistro diventa relativo all'angolo inferiore sinistro, l'offset inferiore relativo al bordo inferiore, e l'offset destro relativo all'angolo inferiore destro del nodo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_VCENTER_WIDE = 13
Aggancia tutti e 4 gli ancoraggi su una linea verticale che taglia a metà il controllo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_HCENTER_WIDE = 14
Aggancia tutti e 4 gli ancoraggi su una linea orizzontale che taglia a metà il controllo padre. Da utilizzare con set_anchors_preset().
LayoutPreset PRESET_FULL_RECT = 15
Aggancia tutti e 4 gli ancoraggi ai rispettivi angoli del controllo padre. Imposta tutti e 4 gli offset a 0 dopo aver applicato questo preset e il Control si adatterà al suo controllo padre. Da utilizzare con set_anchors_preset().
enum LayoutPresetMode: 🔗
LayoutPresetMode PRESET_MODE_MINSIZE = 0
Il controllo sarà ridimensionato alla sua dimensione minima.
LayoutPresetMode PRESET_MODE_KEEP_WIDTH = 1
La larghezza del controllo non cambierà.
LayoutPresetMode PRESET_MODE_KEEP_HEIGHT = 2
L'altezza del controllo non cambierà.
LayoutPresetMode PRESET_MODE_KEEP_SIZE = 3
Le dimensioni del controllo non cambieranno.
flags SizeFlags: 🔗
SizeFlags SIZE_SHRINK_BEGIN = 0
Indica al Container genitore di allineare il nodo con il suo inizio, ossia sul bordo superiore oppure sinistro. È mutuamente esclusivo con SIZE_FILL e altri flag di restringimento delle dimensioni, ma può essere usato con SIZE_EXPAND in alcuni contenitori. Da utilizzare con size_flags_horizontal e size_flags_vertical.
Nota: Impostare questo flag equivale a non avere alcun flag di dimensione.
SizeFlags SIZE_FILL = 1
Indica al Container genitore di espandere i limiti di questo nodo per riempire tutto lo spazio disponibile senza spingere nessun altro nodo. È mutuamente esclusivo con i flag di riduzione delle dimensioni. Da utilizzare con size_flags_horizontal e size_flags_vertical.
SizeFlags SIZE_EXPAND = 2
Indica al Container genitore di lasciare che questo nodo occupi tutto lo spazio disponibile sull'asse indicato. Se più nodi adiacenti sono impostati per espandersi, condivideranno lo spazio in base al loro rapporto di allungamento. Vedi size_flags_stretch_ratio. Da utilizzare con size_flags_horizontal e size_flags_vertical.
SizeFlags SIZE_EXPAND_FILL = 3
Imposta i flag di dimensione del nodo su sia "fill" sia "expand". Vedi SIZE_FILL e SIZE_EXPAND per ulteriori informazioni.
SizeFlags SIZE_SHRINK_CENTER = 4
Indica al Container genitore di centrare il nodo nello spazio disponibile. È mutuamente esclusivo con SIZE_FILL e altri flag di restringimento delle dimensioni, ma può essere usato con SIZE_EXPAND in alcuni contenitori. Da utilizzare con size_flags_horizontal e size_flags_vertical.
SizeFlags SIZE_SHRINK_END = 8
Indica al Container genitore di allineare il nodo con la sua fine, ossia il bordo inferiore oppure destro. È mutuamente esclusivo con SIZE_FILL e altri flag di restringimento delle dimensioni, ma può essere usato con SIZE_EXPAND in alcuni contenitori. Da utilizzare con size_flags_horizontal e size_flags_vertical.
enum MouseFilter: 🔗
MouseFilter MOUSE_FILTER_STOP = 0
Il controllo riceverà eventi di input del movimento del mouse ed eventi di input del pulsante del mouse se cliccato tramite _gui_input(). Il controllo riceverà inoltre i segnali mouse_entered e mouse_exited. Questi eventi sono automaticamente contrassegnati come gestiti e non si propagheranno ulteriormente ad altri controlli. Ciò comporta anche al blocco dei segnali in altri controlli.
MouseFilter MOUSE_FILTER_PASS = 1
Il controllo riceverà eventi di input del movimento del mouse ed eventi di input del pulsante del mouse se cliccato, attraverso _gui_input(). Il controllo riceverà inoltre i segnali mouse_entered e mouse_exited.
Se questo controllo non gestisce l'evento, l'evento verrà propagato al suo controllo genitore, se ne ha uno. L'evento viene propagato verso l'alto nella gerarchia dei nodi finché non raggiunge un nodo che non è CanvasItem, un controllo con MOUSE_FILTER_STOP o un CanvasItem con CanvasItem.top_level abilitato. Ciò consentirà l'invio di segnali a tutti i controlli che l'evento raggiunge. Se nessun controllo lo ha gestito, l'evento sarà passato a Node._shortcut_input() per un'ulteriore elaborazione.
MouseFilter MOUSE_FILTER_IGNORE = 2
Il controllo non riceverà eventi di input del movimento del mouse ed eventi di input del pulsante del mouse se cliccato tramite _gui_input(). Il controllo non riceverà nemmeno i segnali mouse_entered né mouse_exited. Ciò non impedirà ad altri controlli di ricevere questi eventi o di attivare i lori segnali. Gli eventi ignorati non saranno gestiti automaticamente. Se un figlio ha MOUSE_FILTER_PASS e un evento è stato passato a questo controllo, l'evento verrà ulteriormente propagato fino al genitore del controllo .
Nota: Se il controllo ha ricevuto mouse_entered ma non mouse_exited, la modifica di mouse_filter in MOUSE_FILTER_IGNORE causerà l'emissione di mouse_exited.
enum GrowDirection: 🔗
GrowDirection GROW_DIRECTION_BEGIN = 0
Il controllo si espanderà verso sinistra o verso l'alto per compensare, se la sua dimensione minima diventa maggiore della dimensione attuale sul rispettivo asse.
GrowDirection GROW_DIRECTION_END = 1
Il controllo si espanderà verso destra o verso il basso per compensare, se la sua dimensione minima diventa maggiore della dimensione attuale sul rispettivo asse.
GrowDirection GROW_DIRECTION_BOTH = 2
Il controllo si espanderà verso entrambe le direzioni ugualmente per compensare, se la sua dimensione minima diventa maggiore della dimensione attuale.
enum Anchor: 🔗
Anchor ANCHOR_BEGIN = 0
Aggancia uno dei 4 lati di ancoraggio all'origine del Rect del nodo, in alto a sinistra. Usalo con una delle variabili membro anchor_*, come anchor_left. Per cambiare tutti e 4 gli ancoraggi contemporaneamente, usa set_anchors_preset().
Anchor ANCHOR_END = 1
Aggancia uno dei 4 lati di ancoraggio alla fine del Rect del nodo, in basso a destra. Usalo con una delle variabili membro anchor_*, come anchor_left. Per cambiare tutti e 4 gli ancoraggi contemporaneamente, usa set_anchors_preset().
enum LayoutDirection: 🔗
LayoutDirection LAYOUT_DIRECTION_INHERITED = 0
Direzione di layout automatica, determinata dalla direzione di layout del controllo padre.
LayoutDirection LAYOUT_DIRECTION_APPLICATION_LOCALE = 1
Direzione del layout automatica, determinata dalla lingua attuale. La direzione di layout da destra a sinistra viene utilizzata automaticamente per le lingue che la richiedono, come l'arabo e l'ebraico, ma solo se viene caricato un file di traduzione valido per la lingua specificata (a meno che detta lingua non sia configurata come riserva in ProjectSettings.internationalization/locale/fallback). Per tutte le altre lingue (o se Godot non trova alcun file di traduzione valido), è utilizzata la direzione di layout da sinistra a destra. Se si sta utilizzando TextServerFallback (ProjectSettings.internationalization/rendering/text_driver), la direzione di layout da sinistra a destra è sempre utilizzata a prescindere dalla lingua. La direzione di layout da destra a sinistra può anche essere forzata tramite ProjectSettings.internationalization/rendering/force_right_to_left_layout_direction.
LayoutDirection LAYOUT_DIRECTION_LTR = 2
Direzione di layout da sinistra a destra.
LayoutDirection LAYOUT_DIRECTION_RTL = 3
Direzione di layout da destra a sinistra.
LayoutDirection LAYOUT_DIRECTION_SYSTEM_LOCALE = 4
Direzione del layout automatica, determinata dalle impostazioni locali del sistema. La direzione di layout da destra a sinistra è utilizzata automaticamente per le lingue che la richiedono, come l'arabo e l'ebraico, ma solo se è stato caricato un file di traduzione valido per la lingua specificata. Per tutte le altre lingue (o se Godot non trova un file di traduzione valido), è utilizzata la direzione di layout da sinistra a destra. Se si utilizza TextServerFallback (ProjectSettings.internationalization/rendering/text_driver), la direzione di layout da sinistra a destra è sempre utilizzata a prescindere dalla lingua.
LayoutDirection LAYOUT_DIRECTION_MAX = 5
Rappresenta la dimensione dell'enumerazione LayoutDirection.
LayoutDirection LAYOUT_DIRECTION_LOCALE = 1
Deprecato: Use LAYOUT_DIRECTION_APPLICATION_LOCALE instead.
enum TextDirection: 🔗
TextDirection TEXT_DIRECTION_INHERITED = 3
La direzione di scrittura del testo è la stessa della direzione del layout.
TextDirection TEXT_DIRECTION_AUTO = 0
Direzione automatica di scrittura del testo, determinata in base alla lingua attuale e al contenuto del testo.
TextDirection TEXT_DIRECTION_LTR = 1
Direzione di scrittura del testo da sinistra a destra.
TextDirection TEXT_DIRECTION_RTL = 2
Direzione di scrittura del testo da destra a sinistra.
Costanti
NOTIFICATION_RESIZED = 40 🔗
Inviato quando il nodo cambia dimensioni. Usa size per ottenere le nuove dimensioni.
NOTIFICATION_MOUSE_ENTER = 41 🔗
Inviato quando il cursore del mouse entra nell'area visibile del controllo (o di qualsiasi controllo figlio), che non è coperta dietro altri controlli o finestre, a condizione che il suo mouse_filter consenta all'evento di raggiungerlo e a prescindere dal fatto che sia attualmente focalizzato o meno.
Nota: CanvasItem.z_index non influisce sul controllo che riceve il segnale.
Vedi anche NOTIFICATION_MOUSE_ENTER_SELF.
NOTIFICATION_MOUSE_EXIT = 42 🔗
Inviato quando il cursore del mouse esce dall'area visibile del controllo (o di qualsiasi controllo figlio), che non è coperta dietro altri controlli o finestre, a condizione che il suo mouse_filter consenta all'evento di raggiungerlo e a prescindere dal fatto che sia attualmente focalizzato o meno.
Nota: CanvasItem.z_index non influisce sul controllo che riceve il segnale.
Vedi anche NOTIFICATION_MOUSE_EXIT_SELF.
NOTIFICATION_MOUSE_ENTER_SELF = 60 🔗
Sperimentale: The reason this notification is sent may change in the future.
Inviato quando il cursore del mouse entra nell'area visibile del controllo, che non è coperta dietro altri controlli o finestre, a condizione che il suo mouse_filter consenta all'evento di raggiungerlo e a prescindere dal fatto che sia attualmente focalizzato o meno.
Nota: CanvasItem.z_index non influisce sul controllo che riceve il segnale.
Vedi anche NOTIFICATION_MOUSE_ENTER.
NOTIFICATION_MOUSE_EXIT_SELF = 61 🔗
Sperimentale: The reason this notification is sent may change in the future.
Inviato quando il cursore del mouse esce dall'area visibile del controllo, che non è coperta dietro altri controlli o finestre, a condizione che il suo mouse_filter consenta all'evento di raggiungerlo e a prescindere dal fatto che sia attualmente focalizzato o meno.
Nota: CanvasItem.z_index non influisce sul controllo che riceve il segnale.
Vedi anche NOTIFICATION_MOUSE_EXIT.
NOTIFICATION_FOCUS_ENTER = 43 🔗
Inviato quando il nodo cattura il focus.
NOTIFICATION_FOCUS_EXIT = 44 🔗
Sent when the node loses focus.
This notification is sent in reversed order.
NOTIFICATION_THEME_CHANGED = 45 🔗
Inviata quando il nodo ha bisogno di aggiornare i suoi elementi di tema. Ciò avviene in uno dei seguenti casi:
La proprietà theme è cambiata su questo nodo o su uno dei suoi antenati.
La proprietà theme_type_variation è cambiata su questo nodo.
Una delle sostituzioni della proprietà del tema del nodo è cambiata.
Il nodo entra nell'albero di scene.
Nota: Per un ottimizzazione, questa notifica non verrà inviata da modifiche che si verificano mentre questo nodo è al di fuori dell'albero di scene. Invece, tutti gli aggiornamenti degli elementi del tema possono essere applicati subito quando il nodo entra nell'albero di scene.
Nota: Questa notifica è ricevuta insieme a Node.NOTIFICATION_ENTER_TREE, quindi se stai istanziando una scena, i nodi figlio non saranno ancora inizializzati. Puoi usare ciò per impostare il tema per questo nodo, i nodi figlio creati dallo script o, se vuoi accedere ai nodi figlio aggiunti nell'editor, assicurarti che il nodo sia pronto usando Node.is_node_ready().
func _notification(what):
if what == NOTIFICATION_THEME_CHANGED:
if not is_node_ready():
await ready # Aspetta per il segnale ready.
$Label.add_theme_color_override("font_color", Color.YELLOW)
NOTIFICATION_SCROLL_BEGIN = 47 🔗
Inviato quando questo nodo si trova all'interno di uno ScrollContainer che ha iniziato a scorrere trascinando l'area scorrevole con un evento di tocco. Questa notifica non viene inviata quando si scorre trascinando la barra di scorrimento, scorrendo con la rotellina del mouse o scorrendo con eventi da tastiera o da gamepad.
Nota: Questo segnale è emesso solo su Android o iOS, o su piattaforme desktop o web quando ProjectSettings.input_devices/pointing/emulate_touch_from_mouse è abilitato.
NOTIFICATION_SCROLL_END = 48 🔗
Inviato quando questo nodo si trova all'interno di uno ScrollContainer che ha smesso di scorrere trascinando l'area scorrevole con un evento di tocco. Questa notifica non viene inviata quando si scorre trascinando la barra di scorrimento, scorrendo con la rotellina del mouse o scorrendo con eventi da tastiera o da gamepad.
Nota: Questo segnale è emesso solo su Android o iOS, o su piattaforme desktop o web quando ProjectSettings.input_devices/pointing/emulate_touch_from_mouse è abilitato.
NOTIFICATION_LAYOUT_DIRECTION_CHANGED = 49 🔗
Inviata quando la direzione del layout del controllo viene modificata da LTR o RTL, o viceversa. Questa notifica viene propagata ai nodi di controllo figlio come risultato di una modifica a layout_direction.
Descrizioni delle proprietà
Array[NodePath] accessibility_controls_nodes = [] 🔗
I percorsi ai nodi controllati da questo nodo.
Array[NodePath] accessibility_described_by_nodes = [] 🔗
I percorsi ai nodi che descrivono questo nodo.
String accessibility_description = "" 🔗
La descrizione del nodo leggibile in chiaro che è riportata alle applicazioni assistive.
Array[NodePath] accessibility_flow_to_nodes = [] 🔗
I percorsi ai nodi in cui fluisce questo nodo.
Array[NodePath] accessibility_labeled_by_nodes = [] 🔗
I percorsi ai nodi che etichettano questo nodo.
AccessibilityLiveMode accessibility_live = 0 🔗
void set_accessibility_live(value: AccessibilityLiveMode)
AccessibilityLiveMode get_accessibility_live()
La modalità con cui una regione attiva si aggiorna. Una regione attiva è un Node che viene aggiornato in seguito a un evento esterno quando l'attenzione dell'utente potrebbe essere rivolta altrove.
String accessibility_name = "" 🔗
Il nome del nodo leggibile in chiaro che è riportato alle applicazioni assistive.
Ancora il bordo inferiore del nodo all'origine, al centro o alla fine del suo controllo padre. Cambia il modo in cui l'offset inferiore si aggiorna quando il nodo si sposta o cambia dimensione. È possibile usare una delle costanti di Anchor per comodità.
Ancora il bordo sinistro del nodo all'origine, al centro o alla fine del suo controllo padre. Cambia il modo in cui l'offset sinistro si aggiorna quando il nodo si sposta o cambia dimensione. È possibile usare una delle costanti di Anchor per comodità.
Ancora il bordo destro del nodo all'origine, al centro o alla fine del suo controllo padre. Cambia il modo in cui l'offset destro si aggiorna quando il nodo si sposta o cambia dimensione. È possibile usare una delle costanti di Anchor per comodità.
Ancora il bordo superiore del nodo all'origine, al centro o alla fine del suo controllo padre. Cambia il modo in cui l'offset superiore si aggiorna quando il nodo si sposta o cambia dimensione. È possibile usare una delle costanti di Anchor per comodità.
Deprecato: Use Node.auto_translate_mode and Node.can_auto_translate() instead.
Commuta la conversione automatica del testo nella sua versione tradotta, a seconda delle impostazioni locali attuali.
Abilita se il rendering dei figli basati su CanvasItem debba essere ritagliato nel rettangolo di questo controllo. Se true, le parti di un figlio che sarebbero visibili al di fuori del rettangolo di questo controllo non saranno renderizzate e non riceveranno gli input.
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()
Determina quali controlli si possono focalizzare insieme a focus_mode. Vedi get_focus_mode_with_override(). Poiché il comportamento predefinito è FOCUS_BEHAVIOR_INHERITED, questo si può utilizzare per impedire a tutti i controlli figlio di avere il focus.
Determina quali controlli si possono focalizzare. È possibile focalizzare un solo controllo alla volta e il controllo focalizzato riceverà eventi da tastiera, gamepad e mouse in _gui_input(). Usa get_focus_mode_with_override() per determinare se un controllo può ottenere il focus, poiché anche focus_behavior_recursive lo influenza. Vedi anche grab_focus().
NodePath focus_neighbor_bottom = NodePath("") 🔗
Indica a Godot a quale nodo bisogna dare il focus se l'utente preme (come predefinito) la freccia giù sulla tastiera o giù su un gamepad. È possibile cambiare il tasto modificando l'azione di input ProjectSettings.input/ui_down. Il nodo deve essere un Control. Se questa proprietà non è impostata, Godot darà il focus al Control più vicino alla parte inferiore di questo controllo.
NodePath focus_neighbor_left = NodePath("") 🔗
Indica a Godot a quale nodo bisogna dare il focus se l'utente preme (come predefinito) la freccia sinistra sulla tastiera o sinistra su un gamepad. È possibile cambiare il tasto modificando l'azione di input ProjectSettings.input/ui_left. Il nodo deve essere un Control. Se questa proprietà non è impostata, Godot darà il focus al Control più vicino alla parte sinistra di questo controllo.
NodePath focus_neighbor_right = NodePath("") 🔗
Indica a Godot a quale nodo bisogna dare il focus se l'utente preme (come predefinito) la freccia destra sulla tastiera o destra su un gamepad. È possibile cambiare il tasto modificando l'azione di input ProjectSettings.input/ui_right. Il nodo deve essere un Control. Se questa proprietà non è impostata, Godot darà il focus al Control più vicino alla parte destra di questo controllo.
NodePath focus_neighbor_top = NodePath("") 🔗
Indica a Godot a quale nodo bisogna dare il focus se l'utente preme (come predefinito) la freccia su sulla tastiera o su su un gamepad. È possibile cambiare il tasto modificando l'azione di input ProjectSettings.input/ui_up. Il nodo deve essere un Control. Se questa proprietà non è impostata, Godot darà il focus al Control più vicino alla parte superiore di questo controllo.
NodePath focus_next = NodePath("") 🔗
Indica a Godot a quale nodo bisogna dare il focus se l'utente preme (come predefinito) Tab su una tastiera. È possibile modificare il tasto modificando l'azione di input ProjectSettings.input/ui_focus_next.
Se questa proprietà non è impostata, Godot selezionerà una "migliore ipotesi" in base ai nodi circostanti nell'albero di scene.
NodePath focus_previous = NodePath("") 🔗
Indica a Godot a quale nodo bisogna dare il focus se l'utente preme (come predefinito) Shift + Tab su una tastiera. È possibile modificare il tasto modificando l'azione di input ProjectSettings.input/ui_focus_prev.
Se questa proprietà non è impostata, Godot selezionerà una "migliore ipotesi" in base ai nodi circostanti nell'albero di scene.
Vector2 get_global_position()
Posizione globale del nodo, relativa al mondo (solitamente relativa al CanvasLayer).
GrowDirection grow_horizontal = 1 🔗
void set_h_grow_direction(value: GrowDirection)
GrowDirection get_h_grow_direction()
Controlla la direzione sull'asse orizzontale in cui il controllo dovrebbe crescere se la sua dimensione minima orizzontale è modificata per essere maggiore della sua dimensione attuale, affinché il controllo sia largo almeno quanto la larghezza minima.
GrowDirection grow_vertical = 1 🔗
void set_v_grow_direction(value: GrowDirection)
GrowDirection get_v_grow_direction()
Controlla la direzione sull'asse verticale in cui il controllo dovrebbe crescere se la sua dimensione minima orizzontale è modificata per essere maggiore della sua dimensione attuale, affinché il controllo sia alto almeno quanto l'altezza minima.
LayoutDirection layout_direction = 0 🔗
void set_layout_direction(value: LayoutDirection)
LayoutDirection get_layout_direction()
Controlla la direzione del layout e la direzione della scrittura del testo. I layout da destra a sinistra sono necessari per alcune lingue (ad esempio, arabo ed ebraico). Vedi anche is_layout_rtl().
bool localize_numeral_system = true 🔗
Se true, converte automaticamente i numeri di riga del codice, gli indici di elenco, i valori di SpinBox e ProgressBar dall'arabo occidentale (0..9) ai sistemi numerici utilizzati nella lingua attuale.
Nota: I numeri all'interno di testo non sono convertiti automaticamente, è possibile farlo manualmente, tramite TextServer.format_number().
MouseBehaviorRecursive mouse_behavior_recursive = 0 🔗
void set_mouse_behavior_recursive(value: MouseBehaviorRecursive)
MouseBehaviorRecursive get_mouse_behavior_recursive()
Determina quali controlli possono ricevere input del mouse insieme a mouse_filter. Vedi get_mouse_filter_with_override(). Poiché il comportamento predefinito è MOUSE_BEHAVIOR_INHERITED, questo si può utilizzare per impedire a tutti i controlli figlio di ricevere input del mouse.
CursorShape mouse_default_cursor_shape = 0 🔗
void set_default_cursor_shape(value: CursorShape)
CursorShape get_default_cursor_shape()
La forma predefinita del cursore per questo controllo. Utile per le estensioni di Godot e le applicazioni o i giochi che utilizzano i cursori del mouse del sistema.
Nota: Su Linux, le forme potrebbero variare a seconda del tema del cursore del sistema.
MouseFilter mouse_filter = 0 🔗
void set_mouse_filter(value: MouseFilter)
MouseFilter get_mouse_filter()
Determina quali controlli saranno in grado di ricevere eventi di input dei pulsanti del mouse tramite _gui_input() e i segnali mouse_entered e mouse_exited. Determina inoltre come questi eventi si devono propagare. Consulta le costanti per scoprire a cosa serve ciascuna di esse. Usa get_mouse_filter_with_override() per determinare se un controllo può ricevere input del mouse, poiché anche mouse_behavior_recursive lo influenza.
bool mouse_force_pass_scroll_events = true 🔗
Se abilitato, gli eventi della rotellina di scorrimento elaborati da _gui_input() saranno passati al controllo genitore anche se mouse_filter è impostato su MOUSE_FILTER_STOP.
Dovresti disabilitarlo nel controllo radice della tua interfaccia utente se non vuoi che gli eventi di scorrimento vengano elaborati in Node._unhandled_input().
Nota: Poiché questa proprietà è predefinita su true, ciò consente ai contenitori scorrevoli annidati di funzionare senza aver bisogno di modifiche.
Distanza tra il bordo inferiore del nodo e il suo controllo padre, in base a anchor_bottom.
Gli offset sono spesso gestiti da uno o più nodi Container genitori, quindi non dovresti modificarli manualmente se il tuo nodo è un figlio diretto di un Container. Gli offset si aggiornano automaticamente quando sposti o ridimensioni il nodo.
Distanza tra il bordo sinistro del nodo e il suo controllo padre, in base a anchor_left.
Gli offset sono spesso gestiti da uno o più nodi Container genitori, quindi non dovresti modificarli manualmente se il tuo nodo è un figlio diretto di un Container. Gli offset si aggiornano automaticamente quando sposti o ridimensioni il nodo.
Distanza tra il bordo destro del nodo e il suo controllo padre, in base a anchor_right.
Gli offset sono spesso gestiti da uno o più nodi Container genitori, quindi non dovresti modificarli manualmente se il tuo nodo è un figlio diretto di un Container. Gli offset si aggiornano automaticamente quando sposti o ridimensioni il nodo.
Distanza tra il bordo superiore del nodo e il suo controllo padre, in base a anchor_top.
Gli offset sono spesso gestiti da uno o più nodi Container genitori, quindi non dovresti modificarli manualmente se il tuo nodo è un figlio diretto di un Container. Gli offset si aggiornano automaticamente quando sposti o ridimensioni il nodo.
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 posizione del nodo, relativa al nodo che lo contiene. Corrisponde all'angolo in alto a sinistra del rettangolo. Questa proprietà non è influenzata da 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 rotazione del nodo attorno al suo perno, in radianti. Vedi pivot_offset per modificare la posizione del perno.
Nota: Questa proprietà è modificata in gradi nell'ispettore. Se si desidera usare i gradi in uno script, usa invece rotation_degrees.
Proprietà di supporto per accedere al rotation in gradi anziché in radianti.
Vector2 scale = Vector2(1, 1) 🔗
La scala del nodo, relativa alle sue dimensioni (size). Modifica questa proprietà per ridimensionare il nodo attorno al suo pivot_offset. Anche il tooltip_text del Control sarà ridimensionato in base a questo valore.
Nota: Questa proprietà è principalmente progettata per le animazioni. Per supportare più risoluzioni nel tuo progetto, usa una modalità appropriata di stiramento della viewport come descritto nella documentazione, invece di ridimensionare i controlli individualmente.
Nota: FontFile.oversampling non tiene conto della scala del Control. Ciò significa che ingrandire o rimpicciolire il controllo renderà sfocati o pixelati i font bitmap e i font dinamici rasterizzati (non MSDF). Per garantire che il testo rimanga nitido a prescindere dalla scala, è possibile abilitare il rendering dei font MSDF abilitando ProjectSettings.gui/theme/default_font_multichannel_signed_distance_field (si applica solo al font predefinito del progetto) o abilitando Multichannel Signed Distance Field nelle opzioni di importazione di un DynamicFont per font personalizzati. Sui font di sistema, è possibile abilitare SystemFont.multichannel_signed_distance_field nell'Ispettore.
Nota: Se il nodo Control è un figlio di un nodo Container, la scala sarà reimpostata su Vector(1, 1) quando la scena viene istanziata. Per impostare la scala del Control quando viene istanziato, attendi un frame usando await get_tree().process_frame quindi imposta la sua proprietà scale.
Il Node che deve essere un genitore del Control focalizzato affinché la scorciatoia sia attivata. Se null, la scorciatoia può essere attivata quando un controllo qualsiasi è focalizzato (una scorciatoia globale). Ciò consente che le scorciatoie siano accettate solo quando l'utente ha focalizzato una determinata area della GUI.
Vector2 size = Vector2(0, 0) 🔗
Vector2 get_size()
La dimensione del rettangolo di delimitazione del nodo, nel sistema di coordinate del nodo. I nodi Container aggiornano questa proprietà automaticamente.
BitField[SizeFlags] size_flags_horizontal = 1 🔗
Indica ai nodi Container genitori come ridimensionare e posizionare il nodo sull'asse X. Usa una combinazione delle costanti di SizeFlags per modificare i flag. Vedi le costanti per scoprire cosa fa ciascuna.
float size_flags_stretch_ratio = 1.0 🔗
Se il nodo e almeno uno dei suoi vicini utilizzano il flag di dimensione SIZE_EXPAND, il Container genitore gli consentirà di occupare più o meno spazio a seconda di questa proprietà. Se questo nodo ha un rapporto di allungamento di 2 e il suo vicino un rapporto di 1, questo nodo occuperà due terzi dello spazio disponibile.
BitField[SizeFlags] size_flags_vertical = 1 🔗
Indica ai nodi Container genitori come ridimensionare e posizionare il nodo sull'asse Y. Usa una combinazione delle costanti di SizeFlags per modificare i flag. Vedi le costanti per scoprire cosa fa ciascuna.
La risorsa Theme utilizzata da questo nodo e da tutti i suoi figli Control e Window. Se un nodo figlio ha la sua risorsa Theme impostata, gli elementi del tema sono uniti, con definizioni del figlio aventi priorità maggiori.
Nota: Gli stili di Window non avranno effetto a meno che la finestra non sia incorporata.
StringName theme_type_variation = &"" 🔗
void set_theme_type_variation(value: StringName)
StringName get_theme_type_variation()
Il nome di una variazione di tipo del tema, utilizzato da questo Control per cercare i propri elementi del tema. Quando è vuoto, viene utilizzato il nome della classe del nodo (ad esempio Button per il controllo Button), oltre che i nomi di tutte le classi padre (in ordine di ereditarietà).
Quando è impostata, questa proprietà assegna la priorità più alta al tipo del nome specificato. Questo tipo può a sua volta estendere un altro tipo, formando una catena di dipendenze. Vedi Theme.set_type_variation(). Se non è possibile trovare l'elemento del tema usando questo tipo o i suoi tipi di base, la ricerca ricorre ai nomi delle classi.
Nota: Per cercare gli elementi del Control stesso, utilizza i vari metodi get_theme_* senza specificare theme_type.
Nota: Gli elementi del tema sono cercati in ordine ad albero, dal ramo alla radice, dove ogni nodo Control è verificato per la sua proprietà del theme. Sarà restituita la prima corrispondenza con qualsiasi nome di tipo o di classe. Il tema a livello del progetto e il tema predefinito saranno verificati per ultimi.
AutoTranslateMode tooltip_auto_translate_mode = 0 🔗
void set_tooltip_auto_translate_mode(value: AutoTranslateMode)
AutoTranslateMode get_tooltip_auto_translate_mode()
Definisce se il testo del tooltip deve cambiare automaticamente nella sua versione tradotta a seconda delle impostazioni locali attuali. Utilizza la stessa modalità di traduzione automatica di questo controllo quando impostato su Node.AUTO_TRANSLATE_MODE_INHERIT.
Nota: I tooltip personalizzati tramite _make_custom_tooltip() non utilizzano automaticamente questa modalità di traduzione automatica.
Il testo predefinito del tooltip. Il tooltip appare quando il cursore del mouse rimane inattivo su questo controllo per qualche momento, a condizione che la proprietà mouse_filter non sia MOUSE_FILTER_IGNORE. È possibile modificare il tempo necessario per far apparire il tooltip con l'opzione ProjectSettings.gui/timers/tooltip_delay_sec. Vedi anche get_tooltip().
Questa stringa è il valore di ritorno predefinito di get_tooltip(). Sovrascrivi _get_tooltip() per generare dinamicamente il testo del tooltip. Sostituisci _make_custom_tooltip() per personalizzare l'interfaccia e il comportamento del tooltip.
Il popup del tooltip utilizzerà un'implementazione predefinita o una personalizzata, la quale è possibile fornire sovrascrivendo _make_custom_tooltip(). Il tooltip predefinito include un PopupPanel e un Label, le cui proprietà del tema possono essere personalizzate attraverso i metodi di Theme con "TooltipPanel" e "TooltipLabel" rispettivamente. Ad esempio:
var style_box = StyleBoxFlat.new()
style_box.set_bg_color(Color(1, 1, 0))
style_box.set_border_width_all(2)
# Qui supponiamo che alla proprietà `theme` sia stata assegnata in precedenza un tema personalizzato.
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);
// Qui supponiamo che alla proprietà `theme` sia stata assegnata in precedenza un tema personalizzato.
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.
Descrizioni dei metodi
String _accessibility_get_contextual_info() virtual const 🔗
Restituisce la descrizione delle scorciatoie da tastiera e altre informazioni contestuali per questo controllo.
bool _can_drop_data(at_position: Vector2, data: Variant) virtual const 🔗
Godot chiama questo metodo per verificare se data da un _get_drag_data() di un controllo può essere rilasciato nella posizione at_position. at_position è locale a questo controllo.
Questo metodo dovrebbe essere utilizzato solo per verificare i dati. Elabora i dati in _drop_data().
Nota: Se il trascinamento è stato avviato tramite una scorciatoia da tastiera o accessibility_drag(), at_position è impostato su Vector2.INF e si dovrebbe utilizzare la posizione dell'elemento/testo attualmente selezionato come posizione di rilascio.
func _can_drop_data(position, data):
# Controlla la posizione se ti interessa
# Altrimenti, controlla solo i dati
return typeof(data) == TYPE_DICTIONARY and data.has("previsto")
public override bool _CanDropData(Vector2 atPosition, Variant data)
{
// Controlla la posizione se ti interessa
// Altrimenti, controlla solo i dati
return data.VariantType == Variant.Type.Dictionary && data.AsGodotDictionary().ContainsKey("previsto");
}
void _drop_data(at_position: Vector2, data: Variant) virtual 🔗
Godot chiama questo metodo per passare data dal risultato di _get_drag_data() di un controllo. Godot chiama prima _can_drop_data() per verificare se data può essere rilasciato nella posizione at_position, dove at_position è locale a questo controllo.
Nota: Se il trascinamento è stato avviato tramite una scorciatoia da tastiera o accessibility_drag(), at_position è impostato su Vector2.INF e si dovrebbe utilizzare la posizione dell'elemento/testo attualmente selezionato come posizione di rilascio.
func _can_drop_data(position, data):
return typeof(data) == TYPE_DICTIONARY and data.has("colore")
func _drop_data(position, data):
var colore= data["colore"]
public override bool _CanDropData(Vector2 atPosition, Variant data)
{
return data.VariantType == Variant.Type.Dictionary && dict.AsGodotDictionary().ContainsKey("colore");
}
public override void _DropData(Vector2 atPosition, Variant data)
{
Color colore = data.AsGodotDictionary()["colore"].AsColor();
}
String _get_accessibility_container_name(node: Node) virtual const 🔗
Sovrascrivi questo metodo per restituire una descrizione leggibile in chiaro dalla posizione del nodo figlio node nel contenitore personalizzato, aggiunto a 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 chiama questo metodo per ottenere dati che possono essere trascinati e rilasciati su controlli che prevedono dati di rilascio. Restituisce null se non ci sono dati da trascinare. I controlli che vogliono ricevere dati di rilascio devono implementare _can_drop_data() e _drop_data(). La posizione at_position è locale a questo controllo. Il trascinamento può essere forzato con force_drag().
Un'anteprima che seguirà il mouse che dovrebbe rappresentare i dati può essere impostata con set_drag_preview(). Un buon momento per impostare l'anteprima è in questo metodo.
Nota: Se il trascinamento è stato avviato tramite una scorciatoia da tastiera o accessibility_drag(), at_position è impostato su Vector2.INF e si dovrebbe utilizzare la posizione dell'elemento/testo attualmente selezionato come posizione di rilascio.
func _get_drag_data(position):
var mydata = make_data() # Questo è il tuo metodo personalizzato che genera i dati di trascinamento.
set_drag_preview(make_preview(mydata)) # Questo è il tuo metodo personalizzato che genera l'anteprima dei dati di trascinamento.
return mydata
public override Variant _GetDragData(Vector2 atPosition)
{
var myData = MakeData(); // Questo è il tuo metodo personalizzato che genera i dati di trascinamento.
SetDragPreview(MakePreview(myData)); // Questo è il tuo metodo personalizzato che genera l'anteprima dei dati di trascinamento.
return myData;
}
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 🔗
Metodo virtuale da implementare dall'utente. Restituisce le dimensioni minime per questo controllo. Alternativa a custom_minimum_size per regolare le dimensioni minime tramite codice. Le dimensioni minime effettive saranno i valori massimi tra i due (in ogni asse separatamente).
Se non sovrascritto, il valore predefinito è Vector2.ZERO.
Nota: Questo metodo non verrà chiamato quando lo script è collegato a un nodo Control che sovrascrive già le sue dimensioni minime (ad esempio Label, Button, PanelContainer, ecc.). Può essere utilizzato solo con la maggior parte dei nodi GUI basilari, come Control, Container, Panel, ecc.
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 🔗
Metodo virtuale da implementare dall'utente. Sovrascrivi questo metodo per gestire e accettare gli input sugli elementi dell'UI. Vedi anche accept_event().
Esempio: Clicca sul controllo per stampare un messaggio.
func _gui_input(event):
if event is InputEventMouseButton:
if event.button_index == MOUSE_BUTTON_LEFT and event.pressed:
print("Sono stato cliccato! D:")
public override void _GuiInput(InputEvent @event)
{
if (@event is InputEventMouseButton mb)
{
if (mb.ButtonIndex == MouseButton.Left && mb.Pressed)
{
GD.Print("Sono stato cliccato! D:");
}
}
}
Se event eredita InputEventMouse, questo metodo non verrà chiamato quando:
il mouse_filter del controllo è impostato su MOUSE_FILTER_IGNORE;
il controllo è ostruito da un altro controllo sopra di esso, che non ha mouse_filter impostato su MOUSE_FILTER_IGNORE;
il genitore del controllo ha mouse_filter impostato su MOUSE_FILTER_STOP o ha accettato l'evento;
il genitore del controllo ha clip_contents abilitato e la posizione del
eventè all'esterno del rettangolo del genitore;la posizione di
eventè all'esterno del controllo (vedi _has_point()).
Nota: La posizione di event è relativa all'origine di questo controllo.
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 🔗
Funzione di sostituzione dell'algoritmo BiDi definita dall'utente.
Restituisce un Array di Vector3i che rappresentano gli intervalli del testo e direzioni di base del testo, ordinati da sinistra a destra. Gli intervalli devono coprire l'intera sorgente text senza sovrapposizioni. L'algoritmo BiDi verrà utilizzato su ciascun intervallo separatamente.
void accept_event() 🔗
Contrassegna un evento di input come gestito. Una volta accettato un evento di input, la propagazione è interrotta, anche ai nodi in ascolto di Node._unhandled_input() o Node._unhandled_key_input().
Nota: Questo non influisce sui metodi in Input, ma solo sul modo in cui sono propagati gli eventi.
void accessibility_drag() 🔗
Avvia un'operazione di trascinamento senza l'utilizzo del mouse.
void accessibility_drop() 🔗
Termina un'operazione di trascinamento senza l'utilizzo del mouse.
void add_theme_color_override(name: StringName, color: Color) 🔗
Crea una sostituzione locale per un Color di tema con il nome name. Le sostituzioni locali hanno sempre la precedenza quando si recuperano elementi del tema per il controllo. Una sostituzione può essere rimossa con remove_theme_color_override().
Vedi anche get_theme_color().
Esempio: Sostituisci il colore di un Label e reimpostalo in seguito:
# Specificato il nodo Label "MyLabel" figlio, sovrascrivi il suo colore del font con un valore personalizzato.
$MyLabel.add_theme_color_override("font_color", Color(1, 0.5, 0))
# Reimposta il colore del font dell'etichetta figlio.
$MyLabel.remove_theme_color_override("font_color")
# In alternativa, è possibile sovrascriverlo con il valore predefinito dal tipo Label.
$MyLabel.add_theme_color_override("font_color", get_theme_color("font_color", "Label"))
// Specificato il nodo Label "MyLabel" figlio, sovrascrivi il suo colore del font con un valore personalizzato.
GetNode<Label>("MyLabel").AddThemeColorOverride("font_color", new Color(1, 0.5f, 0));
// Reimposta il colore del font dell'etichetta figlio.
GetNode<Label>("MyLabel").RemoveThemeColorOverride("font_color");
In alternativa, è possibile sovrascriverlo con il valore predefinito dal tipo Label.
GetNode<Label>("MyLabel").AddThemeColorOverride("font_color", GetThemeColor("font_color", "Label"));
void add_theme_constant_override(name: StringName, constant: int) 🔗
Crea una sostituzione locale per una costante di tema con il nome name. Le sostituzioni locali hanno sempre la precedenza quando si recuperano elementi del tema per il controllo. Una sostituzione può essere rimossa con remove_theme_constant_override().
Vedi anche get_theme_constant().
void add_theme_font_override(name: StringName, font: Font) 🔗
Crea una sostituzione locale per un Font di tema con il nome name. Le sostituzioni locali hanno sempre la precedenza quando si recuperano elementi del tema per il controllo. Una sostituzione può essere rimossa con remove_theme_font_override().
Vedi anche get_theme_font().
void add_theme_font_size_override(name: StringName, font_size: int) 🔗
Crea una sostituzione locale per una dimensione di Font di tema con il nome name. Le sostituzioni locali hanno sempre la precedenza quando si recuperano elementi del tema per il controllo. Una sostituzione può essere rimossa con remove_theme_font_size_override().
Vedi anche get_theme_font_size().
void add_theme_icon_override(name: StringName, texture: Texture2D) 🔗
Crea una sostituzione locale per un'icona di tema con il nome name. Le sostituzioni locali hanno sempre la precedenza quando si recuperano elementi del tema per il controllo. Una sostituzione può essere rimossa con remove_theme_icon_override().
Vedi anche get_theme_icon().
void add_theme_stylebox_override(name: StringName, stylebox: StyleBox) 🔗
Crea una sostituzione locale per lo StyleBox di tema con il nome name. Le sostituzioni locali hanno sempre la precedenza quando si recuperano elementi del tema per il controllo. Una sostituzione può essere rimossa con remove_theme_stylebox_override().
Vedi anche get_theme_stylebox().
Esempio: Modifica una proprietà in uno StyleBox duplicandola:
# Lo snippet seguente assume che al nodo figlio "MyButton" sia assegnato uno StyleBoxFlat.
# Le risorse sono condivise tra le istanze, quindi dobbiamo duplicarle
# per evitare di modificare l'aspetto di tutti gli altri pulsanti.
var new_stylebox_normal = $MyButton.get_theme_stylebox("normal").duplicate()
new_stylebox_normal.border_width_top = 3
new_stylebox_normal.border_color = Color(0, 1, 0.5)
$MyButton.add_theme_stylebox_override("normal", new_stylebox_normal)
# Rimuovi la sostituzione dello stylebox.
$MyButton.remove_theme_stylebox_override("normal")
// Lo snippet seguente assume che al nodo figlio "MyButton" sia assegnato uno StyleBoxFlat.
// Le risorse sono condivise tra le istanze, quindi dobbiamo duplicarle
// per evitare di modificare l'aspetto di tutti gli altri pulsanti.
StyleBoxFlat newStyleboxNormal = GetNode<Button>("MyButton").GetThemeStylebox("normal").Duplicate() as StyleBoxFlat;
newStyleboxNormal.BorderWidthTop = 3;
newStyleboxNormal.BorderColor = new Color(0, 1, 0.5f);
GetNode<Button>("MyButton").AddThemeStyleboxOverride("normal", newStyleboxNormal);
// Rimuovi la sostituzione dello stylebox.
GetNode<Button>("MyButton").RemoveThemeStyleboxOverride("normal");
void begin_bulk_theme_override() 🔗
Impedisce ai metodi *_theme_*_override di emettere NOTIFICATION_THEME_CHANGED finché non viene chiamato end_bulk_theme_override().
void end_bulk_theme_override() 🔗
Termina un aggiornamento di sostituzioni del tema in massa. Vedi begin_bulk_theme_override().
Control find_next_valid_focus() const 🔗
Trova il Control successivo (in basso nell'albero) che può ricevere il focus.
Control find_prev_valid_focus() const 🔗
Trova il Control precedente (in alto nell'albero) che può ricevere il focus.
Control find_valid_focus_neighbor(side: Side) const 🔗
Trova il Control successivo che può ricevere il focus sul lato (Side) specificato.
Nota: Questo è diverso da get_focus_neighbor(), che restituisce il percorso di un vicino di focus specificato.
void force_drag(data: Variant, preview: Control) 🔗
Forza il trascinamento e ignora _get_drag_data() e set_drag_preview() passando data e preview. Il trascinamento inizierà anche se il mouse non è né sopra né premuto su questo controllo.
I metodi _can_drop_data() e _drop_data() devono essere implementati sui controlli che vogliono ricevere dati di rilascio.
float get_anchor(side: Side) const 🔗
Restituisce l'ancora per il lato (Side) specificato. Un metodo getter per anchor_bottom, anchor_left, anchor_right e anchor_top.
Restituisce offset_left e offset_top. Vedi anche 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.
Restituisce offset_right e offset_bottom.
FocusMode get_focus_mode_with_override() const 🔗
Restituisce focus_mode, ma tiene conto di focus_behavior_recursive. Se focus_behavior_recursive è impostato su FOCUS_BEHAVIOR_DISABLED, oppure è impostato su FOCUS_BEHAVIOR_INHERITED e il suo antenato è impostato su FOCUS_BEHAVIOR_DISABLED, allora restituisce FOCUS_NONE.
NodePath get_focus_neighbor(side: Side) const 🔗
Restituisce il vicino di focus per il lato (Side) specificato. Un metodo getter per focus_neighbor_bottom, focus_neighbor_left, focus_neighbor_right e focus_neighbor_top.
Nota: Per trovare il Control successivo sul Side specifico, anche se non è assegnato un vicino, usa find_valid_focus_neighbor().
Rect2 get_global_rect() const 🔗
Restituisce la posizione e la dimensione del controllo relativamente al canvas che lo contiene. Vedi global_position e size.
Nota: Se il nodo stesso o qualsiasi CanvasItem padre tra il nodo e il canvas hanno una rotazione o un'inclinazione non predefinita, la dimensione risultante è probabilmente inutile.
Nota: Impostare Viewport.gui_snap_controls_to_pixels su true può causare imprecisioni di arrotondamento tra il controllo visualizzato e il Rect2 restituito.
Vector2 get_maximum_size() const 🔗
Returns the maximum size for this control. See custom_maximum_size.
Vector2 get_minimum_size() const 🔗
Restituisce le dimensioni minime per questo controllo. Vedi custom_minimum_size.
MouseFilter get_mouse_filter_with_override() const 🔗
Restituisce mouse_filter, ma tiene conto di mouse_behavior_recursive. Se mouse_behavior_recursive è impostato su MOUSE_BEHAVIOR_DISABLED, oppure è impostato su MOUSE_BEHAVIOR_INHERITED e il suo antenato è impostato su MOUSE_BEHAVIOR_DISABLED, allora restituisce MOUSE_FILTER_IGNORE.
float get_offset(offset: Side) const 🔗
Restituisce l'offset per il lato specificato (Side). Un metodo getter per offset_bottom, offset_left, offset_right, e offset_top.
Vector2 get_parent_area_size() const 🔗
Restituisce la larghezza/altezza occupata nel controllo padre.
Control get_parent_control() const 🔗
Restituisce il nodo di controllo padre.
Restituisce la posizione e la dimensione del controllo nel sistema di coordinate del nodo contenitore. Vedi position, scale e size.
Nota: Se rotation non è la rotazione predefinita, la dimensione risultante è inutile.
Nota: Impostare Viewport.gui_snap_controls_to_pixels su true può causare imprecisioni di arrotondamento tra il controllo visualizzato e il Rect2 restituito.
Vector2 get_screen_position() const 🔗
Returns the position of this Control in global screen coordinates (i.e. taking window position into account). Mostly useful for editor plugins.
Equivalent to get_screen_transform().origin (see CanvasItem.get_screen_transform()).
Example: Show a popup at the mouse position:
popup_menu.position = get_screen_position() + get_screen_transform().basis_xform(get_local_mouse_position())
# The above code is equivalent to:
popup_menu.position = get_screen_transform() * get_local_mouse_position()
popup_menu.reset_size()
popup_menu.popup()
Color get_theme_color(name: StringName, theme_type: StringName = &"") const 🔗
Restituisce un Color dal primo Theme corrispondente nell'albero se quel Theme ha un elemento di colore con il nome name e il tipo theme_type specificati. Se theme_type è omesso, il nome della classe del controllo attuale viene utilizzato come tipo, oppure theme_type_variation se è definito. Se il tipo è un nome di classe, anche le sue classi padre sono verificate, in ordine di ereditarietà. Se il tipo è una variazione, i suoi tipi di base sono verificati, in ordine di dipendenza, quindi il nome della classe del controllo e le sue classi padre sono verificati.
Per il controllo attuale, sono considerati prima le sue sostituzioni locali (vedi add_theme_color_override()), poi il suo theme assegnato. Dopo il controllo attuale, sono considerati ogni controllo padre e il suo theme assegnato; i controlli senza un theme assegnato sono ignorati. Se nessun Theme corrispondente nell'albero è trovato, sono utilizzati il Theme personalizzato del progetto (vedi ProjectSettings.gui/theme/custom) e il Theme predefinito (vedi ThemeDB).
func _ready():
# Ottieni il colore del font definito per la classe del controllo attuale, se esiste.
modulate = get_theme_color("font_color")
# Ottieni il colore del font definito per la classe Button.
modulate = get_theme_color("font_color", "Button")
public override void _Ready()
{
// Ottieni il colore del font definito per la classe del controllo attuale, se esiste.
Modulate = GetThemeColor("font_color");
// Ottieni il colore del font definito per la classe Button.
Modulate = GetThemeColor("font_color", "Button"); }
}
int get_theme_constant(name: StringName, theme_type: StringName = &"") const 🔗
Restituisce una costante dal primo Theme corrispondente nell'albero se quel Theme ha un elemento di costante con il nome name e il tipo theme_type specificati.
Vedi get_theme_color() per i dettagli.
float get_theme_default_base_scale() const 🔗
Restituisce il valore di scala di base predefinito dal primo Theme corrispondente nell'albero se quel Theme ha un valore Theme.default_base_scale valido.
Vedi get_theme_color() per i dettagli.
Font get_theme_default_font() const 🔗
Restituisce il font predefinito dal primo Theme corrispondente nell'albero se quel Theme ha un valore Theme.default_font valido.
Vedi get_theme_color() per i dettagli.
int get_theme_default_font_size() const 🔗
Restituisce la dimensione di font predefinito dal primo Theme corrispondente nell'albero se quel Theme ha un valore Theme.default_font_size valido.
Vedi get_theme_color() per i dettagli.
Font get_theme_font(name: StringName, theme_type: StringName = &"") const 🔗
Restituisce un Font dal primo Theme corrispondente nell'albero se quel Theme ha un elemento di font con il nome name e il tipo theme_type specificati.
Vedi get_theme_color() per i dettagli.
int get_theme_font_size(name: StringName, theme_type: StringName = &"") const 🔗
Restituisce una dimensione di Font dal primo Theme corrispondente nell'albero se quel Theme ha un elemento di dimensione di font con il nome name e il tipo theme_type specificati.
Vedi get_theme_color() per i dettagli.
Texture2D get_theme_icon(name: StringName, theme_type: StringName = &"") const 🔗
Restituisce un'icona dal primo Theme corrispondente nell'albero se quel Theme ha un elemento di icona con il nome name e il tipo theme_type specificati.
Vedi get_theme_color() per i dettagli.
StyleBox get_theme_stylebox(name: StringName, theme_type: StringName = &"") const 🔗
Restituisce uno StyleBox dal primo Theme corrispondente nell'albero se quel Theme ha un elemento di stylebox con il nome name e il tipo theme_type specificati.
Vedi get_theme_color() per i dettagli.
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() 🔗
Crea un InputEventMouseButton che tenta di cliccare sul controllo. Se l'evento viene ricevuto, il controllo acquisisce il focus.
func _process(delta):
grab_click_focus() # Quando si clicca su un altro nodo Control, questo nodo verrà invece cliccato.
public override void _Process(double delta)
{
GrabClickFocus(); // Quando si clicca su un altro nodo Control, questo nodo verrà invece cliccato.
}
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 🔗
Restituisce true se nell'albero è presente un Theme corrispondente che ha un elemento colore con il nome name e il tipo theme_type specificati.
Vedi get_theme_color() per i dettagli.
bool has_theme_color_override(name: StringName) const 🔗
Restituisce true se è presente una sostituzione locale per un Color di tema con il nome specificato (name) in questo nodo Control.
Vedi add_theme_color_override().
bool has_theme_constant(name: StringName, theme_type: StringName = &"") const 🔗
Restituisce true se nell'albero è presente un Theme corrispondente che ha un elemento costante con il nome name e il tipo theme_type specificati.
Vedi get_theme_color() per i dettagli.
bool has_theme_constant_override(name: StringName) const 🔗
Restituisce true se è presente una sostituzione locale per una costante di tema con il nome specificato (name) in questo nodo Control.
Vedi add_theme_constant_override().
bool has_theme_font(name: StringName, theme_type: StringName = &"") const 🔗
Restituisce true se nell'albero è presente un Theme corrispondente che ha un elemento di Font con il nome name e il tipo theme_type specificati.
Vedi get_theme_color() per i dettagli.
bool has_theme_font_override(name: StringName) const 🔗
Restituisce true se è presente una sostituzione locale per un Font di tema con il nome specificato (name) in questo nodo Control.
Vedi add_theme_font_override().
bool has_theme_font_size(name: StringName, theme_type: StringName = &"") const 🔗
Restituisce true se nell'albero è presente un Theme corrispondente che ha un elemento di dimensione di Font con il nome name e il tipo theme_type specificati.
Vedi get_theme_color() per i dettagli.
bool has_theme_font_size_override(name: StringName) const 🔗
Restituisce true se è presente una sostituzione locale per una dimensione di font di tema con il nome specificato (name) in questo nodo Control.
Vedi add_theme_font_size_override().
bool has_theme_icon(name: StringName, theme_type: StringName = &"") const 🔗
Restituisce true se nell'albero è presente un Theme corrispondente che ha un elemento icona con il nome name e il tipo theme_type specificati.
Vedi get_theme_color() per i dettagli.
bool has_theme_icon_override(name: StringName) const 🔗
Restituisce true se è presente una sostituzione locale per un'icona di tema con il nome specificato (name) in questo nodo Control.
Vedi add_theme_icon_override().
bool has_theme_stylebox(name: StringName, theme_type: StringName = &"") const 🔗
Restituisce true se nell'albero è presente un Theme corrispondente che ha un elemento StyleBox con il nome name e il tipo theme_type specificati.
Vedi get_theme_color() per i dettagli.
bool has_theme_stylebox_override(name: StringName) const 🔗
Restituisce true se è presente una sostituzione locale per una StyleBox di tema con il nome specificato (name) in questo nodo Control.
Vedi add_theme_stylebox_override().
bool is_drag_successful() const 🔗
Restituisce true se un'operazione di trascinamento è avvenuta con successo. Alternativa a Viewport.gui_is_drag_successful().
Meglio usata con Node.NOTIFICATION_DRAG_END.
Restituisce true se il layout è da destra a sinistra. Vedi anche layout_direction.
void release_focus() 🔗
Rilascia il focus. Nessun altro controllo sarà in grado di ricevere input.
void remove_theme_color_override(name: StringName) 🔗
Rimuove una sostituzione locale per un Color di tema, con il nome name, precedentemente aggiunto da add_theme_color_override() o tramite il pannello dell'Ispettore.
void remove_theme_constant_override(name: StringName) 🔗
Rimuove una sostituzione locale per una costante di tema, con il nome name, precedentemente aggiunta da add_theme_constant_override() o tramite il pannello dell'Ispettore.
void remove_theme_font_override(name: StringName) 🔗
Rimuove una sostituzione locale per un Font di tema, con il nome name, precedentemente aggiunto da add_theme_font_override() o tramite il pannello dell'Ispettore.
void remove_theme_font_size_override(name: StringName) 🔗
Rimuove una sostituzione locale per una dimensione di font Font di tema, con il nome name, precedentemente aggiunta da add_theme_font_size_override() o tramite il pannello dell'Ispettore.
void remove_theme_icon_override(name: StringName) 🔗
Rimuove una sostituzione locale per un'icona di tema, con il nome name, precedentemente aggiunta da add_theme_icon_override() o tramite il pannello dell'Ispettore.
void remove_theme_stylebox_override(name: StringName) 🔗
Rimuove una sostituzione locale per uno StyleBox di tema, con il nome name, precedentemente aggiunto da add_theme_stylebox_override() o tramite il pannello dell'Ispettore.
void reset_size() 🔗
Reimposta le dimensioni a get_combined_minimum_size(). Ciò equivale a chiamare set_size(Vector2()) (o qualsiasi dimensioni al di sotto delle minime).
void set_anchor(side: Side, anchor: float, keep_offset: bool = false, push_opposite_anchor: bool = true) 🔗
Imposta l'ancora per il lato specificato (Side) a anchor. Un metodo setter per anchor_bottom, anchor_left, anchor_right, e anchor_top.
Se keep_offset è true, gli offset non sono aggiornati dopo questa operazione.
Se push_opposite_anchor è true e l'ancora opposta si sovrappone a questa ancora, quella opposta avrà il suo valore sovrascritto. Ad esempio, quando si imposta l'ancora sinistra su 1 e l'ancora destra ha un valore di 0,5, anche l'ancora destra otterrà il valore di 1. Se push_opposite_anchor fosse false, l'ancora sinistra otterrebbe il valore 0,5.
void set_anchor_and_offset(side: Side, anchor: float, offset: float, push_opposite_anchor: bool = false) 🔗
Funziona come set_anchor(), ma invece dell'argomento keep_offset e dell'aggiornamento automatico dell'offset, consente di impostare l'offset autonomamente (vedi set_offset()).
void set_anchors_and_offsets_preset(preset: LayoutPreset, resize_mode: LayoutPresetMode = 0, margin: int = 0) 🔗
Imposta sia il preset di ancore sia il preset di offset. Vedi set_anchors_preset() e set_offsets_preset().
void set_anchors_preset(preset: LayoutPreset, keep_offsets: bool = false) 🔗
Imposta gli ancoraggi a preset, come costante di LayoutPreset. Questo è il codice equivalente all'utilizzo del menu Layout nell'editor 2D.
Se keep_offsets è true, sarà aggiornata anche la posizione del controllo.
void set_begin(position: Vector2) 🔗
Imposta offset_left e offset_top contemporaneamente. Equivale a modificare position.
void set_drag_forwarding(drag_func: Callable, can_drop_func: Callable, drop_func: Callable) 🔗
Imposta i chiamabili specificati da utilizzare al posto dei metodi virtuali drag-and-drop del controllo. Se un chiamabile è vuoto, il suo rispettivo metodo virtuale viene utilizzato normalmente.
Gli argomenti per ogni chiamabile devono essere esattamente gli stessi dei rispettivi metodi virtuali, che sarebbero:
drag_funccorrisponde a _get_drag_data() e richiede un Vector2;can_drop_funccorrisponde a _can_drop_data() e richiede sia un Vector2 sia un Variant;drop_funccorrisponde a _drop_data() e richiede sia un Vector2 sia un Variant.
void set_drag_preview(control: Control) 🔗
Mostra il controllo specificato al puntatore del mouse. Un buon momento per chiamare questo metodo è in _get_drag_data(). Il controllo non deve essere nell'albero di scene. Non dovresti liberare il controllo e non dovresti mantenere un riferimento al controllo oltre la durata del trascinamento. Sarà eliminato automaticamente al termine del trascinamento.
@export var color = Color(1, 0, 0, 1)
func _get_drag_data(position):
# Usa un controllo che non è nell'albero
var cpb = ColorPickerButton.new()
cpb.color = color
cpb.size = Vector2(50, 50)
set_drag_preview(cpb)
return color
[Export]
private Color _color = new Color(1, 0, 0, 1);
public override Variant _GetDragData(Vector2 atPosition)
{
// Usa un controllo che non è nell'albero
var cpb = new ColorPickerButton();
cpb.Color = _color;
cpb.Size = new Vector2(50, 50);
SetDragPreview(cpb);
return _color;
}
void set_end(position: Vector2) 🔗
Imposta offset_right e offset_bottom contemporaneamente.
void set_focus_neighbor(side: Side, neighbor: NodePath) 🔗
Imposta il vicino di focus per il lato (Side) specificato sul Control nel percorso di nodo neighbor. Un metodo setter per focus_neighbor_bottom, focus_neighbor_left, focus_neighbor_right e focus_neighbor_top.
void set_global_position(position: Vector2, keep_offsets: bool = false) 🔗
Imposta global_position sul position specificato.
Se keep_offsets è true, gli ancoraggi del controllo saranno aggiornati al posto degli offset.
void set_offset(side: Side, offset: float) 🔗
Imposta l'offset per il lato (Side) specificato a offset. Un metodo setter per offset_bottom, offset_left, offset_right e offset_top.
void set_offsets_preset(preset: LayoutPreset, resize_mode: LayoutPresetMode = 0, margin: int = 0) 🔗
Imposta gli offset su un preset dall'enumerazione LayoutPreset. Questo è l'equivalente in codice all'utilizzo del menu Layout nell'editor 2D.
Utilizza il parametro resize_mode con le costanti da LayoutPresetMode per determinare meglio la dimensione risultante del Control. La dimensione costante sarà ignorata se utilizzata con i preset che cambiano dimensione, ad esempio PRESET_LEFT_WIDE.
Utilizza il parametro margin per determinare lo spazio tra il Control e i bordi.
void set_position(position: Vector2, keep_offsets: bool = false) 🔗
Imposta position sul position specificato.
Se keep_offsets è true, gli ancoraggi del controllo saranno aggiornati al posto degli offset.
void set_size(size: Vector2, keep_offsets: bool = false) 🔗
Imposta le dimensioni (vedi size).
Se keep_offsets è true, gli ancoraggi del controllo saranno aggiornati al posto degli offset.
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) 🔗
Sposta il cursore del mouse sulla posizione position, che è relativa alla posizione (position) di questo Control.
Nota: warp_mouse() è supportato solo su Windows, macOS, e Linux. Non ha effetto su Android, iOS e Web.