mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2025-12-31 09:49:22 +03:00
359 lines
18 KiB
ReStructuredText
359 lines
18 KiB
ReStructuredText
:github_url: hide
|
|
|
|
.. _class_InputEventKey:
|
|
|
|
InputEventKey
|
|
=============
|
|
|
|
**Hereda:** :ref:`InputEventWithModifiers<class_InputEventWithModifiers>` **<** :ref:`InputEventFromWindow<class_InputEventFromWindow>` **<** :ref:`InputEvent<class_InputEvent>` **<** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
|
|
|
|
Representa una tecla de un teclado que se está pulsando o soltando.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Descripción
|
|
----------------------
|
|
|
|
Un evento de entrada para las teclas de un teclado. Admite pulsaciones de teclas, liberaciones de teclas y eventos :ref:`echo<class_InputEventKey_property_echo>`. También se puede recibir en :ref:`Node._unhandled_key_input()<class_Node_private_method__unhandled_key_input>`.
|
|
|
|
\ **Nota:** Los eventos recibidos del teclado suelen tener todas las propiedades establecidas. Las asignaciones de eventos deben tener solo uno de los :ref:`keycode<class_InputEventKey_property_keycode>`, :ref:`physical_keycode<class_InputEventKey_property_physical_keycode>` o :ref:`unicode<class_InputEventKey_property_unicode>` establecidos.
|
|
|
|
Cuando se comparan los eventos, las propiedades se comprueban en el siguiente orden de prioridad: :ref:`keycode<class_InputEventKey_property_keycode>`, :ref:`physical_keycode<class_InputEventKey_property_physical_keycode>` y :ref:`unicode<class_InputEventKey_property_unicode>`. Los eventos con el primer valor coincidente se considerarán iguales.
|
|
|
|
.. rst-class:: classref-introduction-group
|
|
|
|
Tutoriales
|
|
--------------------
|
|
|
|
- :doc:`Usando InputEvent <../tutorials/inputs/inputevent>`
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Propiedades
|
|
----------------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+---------------------------------------------------+------------------------------------------------------------------------+-----------+
|
|
| :ref:`bool<class_bool>` | :ref:`echo<class_InputEventKey_property_echo>` | ``false`` |
|
|
+---------------------------------------------------+------------------------------------------------------------------------+-----------+
|
|
| :ref:`Key<enum_@GlobalScope_Key>` | :ref:`key_label<class_InputEventKey_property_key_label>` | ``0`` |
|
|
+---------------------------------------------------+------------------------------------------------------------------------+-----------+
|
|
| :ref:`Key<enum_@GlobalScope_Key>` | :ref:`keycode<class_InputEventKey_property_keycode>` | ``0`` |
|
|
+---------------------------------------------------+------------------------------------------------------------------------+-----------+
|
|
| :ref:`KeyLocation<enum_@GlobalScope_KeyLocation>` | :ref:`location<class_InputEventKey_property_location>` | ``0`` |
|
|
+---------------------------------------------------+------------------------------------------------------------------------+-----------+
|
|
| :ref:`Key<enum_@GlobalScope_Key>` | :ref:`physical_keycode<class_InputEventKey_property_physical_keycode>` | ``0`` |
|
|
+---------------------------------------------------+------------------------------------------------------------------------+-----------+
|
|
| :ref:`bool<class_bool>` | :ref:`pressed<class_InputEventKey_property_pressed>` | ``false`` |
|
|
+---------------------------------------------------+------------------------------------------------------------------------+-----------+
|
|
| :ref:`int<class_int>` | :ref:`unicode<class_InputEventKey_property_unicode>` | ``0`` |
|
|
+---------------------------------------------------+------------------------------------------------------------------------+-----------+
|
|
|
|
.. rst-class:: classref-reftable-group
|
|
|
|
Métodos
|
|
--------------
|
|
|
|
.. table::
|
|
:widths: auto
|
|
|
|
+-----------------------------------+--------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`String<class_String>` | :ref:`as_text_key_label<class_InputEventKey_method_as_text_key_label>`\ (\ ) |const| |
|
|
+-----------------------------------+--------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`String<class_String>` | :ref:`as_text_keycode<class_InputEventKey_method_as_text_keycode>`\ (\ ) |const| |
|
|
+-----------------------------------+--------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`String<class_String>` | :ref:`as_text_location<class_InputEventKey_method_as_text_location>`\ (\ ) |const| |
|
|
+-----------------------------------+--------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`String<class_String>` | :ref:`as_text_physical_keycode<class_InputEventKey_method_as_text_physical_keycode>`\ (\ ) |const| |
|
|
+-----------------------------------+--------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Key<enum_@GlobalScope_Key>` | :ref:`get_key_label_with_modifiers<class_InputEventKey_method_get_key_label_with_modifiers>`\ (\ ) |const| |
|
|
+-----------------------------------+--------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Key<enum_@GlobalScope_Key>` | :ref:`get_keycode_with_modifiers<class_InputEventKey_method_get_keycode_with_modifiers>`\ (\ ) |const| |
|
|
+-----------------------------------+--------------------------------------------------------------------------------------------------------------------------+
|
|
| :ref:`Key<enum_@GlobalScope_Key>` | :ref:`get_physical_keycode_with_modifiers<class_InputEventKey_method_get_physical_keycode_with_modifiers>`\ (\ ) |const| |
|
|
+-----------------------------------+--------------------------------------------------------------------------------------------------------------------------+
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descripciones de Propiedades
|
|
--------------------------------------------------------
|
|
|
|
.. _class_InputEventKey_property_echo:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **echo** = ``false`` :ref:`🔗<class_InputEventKey_property_echo>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_echo**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_bool>` **is_echo**\ (\ )
|
|
|
|
If ``true``, the key was already pressed before this event. An echo event is a repeated key event sent when the user is holding down the key.
|
|
|
|
\ **Note:** The rate at which echo events are sent is typically around 20 events per second (after holding down the key for roughly half a second). However, the key repeat delay/speed can be changed by the user or disabled entirely in the operating system settings. To ensure your project works correctly on all configurations, do not assume the user has a specific key repeat configuration in your project's behavior.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_InputEventKey_property_key_label:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Key<enum_@GlobalScope_Key>` **key_label** = ``0`` :ref:`🔗<class_InputEventKey_property_key_label>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_key_label**\ (\ value\: :ref:`Key<enum_@GlobalScope_Key>`\ )
|
|
- :ref:`Key<enum_@GlobalScope_Key>` **get_key_label**\ (\ )
|
|
|
|
Represents the localized label printed on the key in the current keyboard layout, which corresponds to one of the :ref:`Key<enum_@GlobalScope_Key>` constants or any valid Unicode character. Key labels are meant for key prompts.
|
|
|
|
For keyboard layouts with a single label on the key, it is equivalent to :ref:`keycode<class_InputEventKey_property_keycode>`.
|
|
|
|
To get a human-readable representation of the **InputEventKey**, use ``OS.get_keycode_string(event.key_label)`` where ``event`` is the **InputEventKey**.
|
|
|
|
.. code:: text
|
|
|
|
+-----+ +-----+
|
|
| Q | | Q | - "Q" - keycode
|
|
| Й | | ض | - "Й" and "ض" - key_label
|
|
+-----+ +-----+
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_InputEventKey_property_keycode:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Key<enum_@GlobalScope_Key>` **keycode** = ``0`` :ref:`🔗<class_InputEventKey_property_keycode>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_keycode**\ (\ value\: :ref:`Key<enum_@GlobalScope_Key>`\ )
|
|
- :ref:`Key<enum_@GlobalScope_Key>` **get_keycode**\ (\ )
|
|
|
|
Latin label printed on the key in the current keyboard layout, which corresponds to one of the :ref:`Key<enum_@GlobalScope_Key>` constants. Key codes are meant for shortcuts expressed with a standard Latin keyboard, such as :kbd:`Ctrl + S` for a "Save" shortcut.
|
|
|
|
To get a human-readable representation of the **InputEventKey**, use ``OS.get_keycode_string(event.keycode)`` where ``event`` is the **InputEventKey**.
|
|
|
|
.. code:: text
|
|
|
|
+-----+ +-----+
|
|
| Q | | Q | - "Q" - keycode
|
|
| Й | | ض | - "Й" and "ض" - key_label
|
|
+-----+ +-----+
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_InputEventKey_property_location:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`KeyLocation<enum_@GlobalScope_KeyLocation>` **location** = ``0`` :ref:`🔗<class_InputEventKey_property_location>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_location**\ (\ value\: :ref:`KeyLocation<enum_@GlobalScope_KeyLocation>`\ )
|
|
- :ref:`KeyLocation<enum_@GlobalScope_KeyLocation>` **get_location**\ (\ )
|
|
|
|
Represents the location of a key which has both left and right versions, such as :kbd:`Shift` or :kbd:`Alt`.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_InputEventKey_property_physical_keycode:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`Key<enum_@GlobalScope_Key>` **physical_keycode** = ``0`` :ref:`🔗<class_InputEventKey_property_physical_keycode>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_physical_keycode**\ (\ value\: :ref:`Key<enum_@GlobalScope_Key>`\ )
|
|
- :ref:`Key<enum_@GlobalScope_Key>` **get_physical_keycode**\ (\ )
|
|
|
|
Represents the physical location of a key on the 101/102-key US QWERTY keyboard, which corresponds to one of the :ref:`Key<enum_@GlobalScope_Key>` constants. Physical key codes meant for game input, such as WASD movement, where only the location of the keys is important.
|
|
|
|
To get a human-readable representation of the **InputEventKey**, use :ref:`OS.get_keycode_string()<class_OS_method_get_keycode_string>` in combination with :ref:`DisplayServer.keyboard_get_keycode_from_physical()<class_DisplayServer_method_keyboard_get_keycode_from_physical>` or :ref:`DisplayServer.keyboard_get_label_from_physical()<class_DisplayServer_method_keyboard_get_label_from_physical>`:
|
|
|
|
|
|
.. tabs::
|
|
|
|
.. code-tab:: gdscript
|
|
|
|
func _input(event):
|
|
if event is InputEventKey:
|
|
var keycode = DisplayServer.keyboard_get_keycode_from_physical(event.physical_keycode)
|
|
var label = DisplayServer.keyboard_get_label_from_physical(event.physical_keycode)
|
|
print(OS.get_keycode_string(keycode))
|
|
print(OS.get_keycode_string(label))
|
|
|
|
.. code-tab:: csharp
|
|
|
|
public override void _Input(InputEvent @event)
|
|
{
|
|
if (@event is InputEventKey inputEventKey)
|
|
{
|
|
var keycode = DisplayServer.KeyboardGetKeycodeFromPhysical(inputEventKey.PhysicalKeycode);
|
|
var label = DisplayServer.KeyboardGetLabelFromPhysical(inputEventKey.PhysicalKeycode);
|
|
GD.Print(OS.GetKeycodeString(keycode));
|
|
GD.Print(OS.GetKeycodeString(label));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_InputEventKey_property_pressed:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`bool<class_bool>` **pressed** = ``false`` :ref:`🔗<class_InputEventKey_property_pressed>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_pressed**\ (\ value\: :ref:`bool<class_bool>`\ )
|
|
- :ref:`bool<class_bool>` **is_pressed**\ (\ )
|
|
|
|
Si es ``true``, se pulsa el estado de la tecla. Si es ``false``, el estado de la tecla se libera.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_InputEventKey_property_unicode:
|
|
|
|
.. rst-class:: classref-property
|
|
|
|
:ref:`int<class_int>` **unicode** = ``0`` :ref:`🔗<class_InputEventKey_property_unicode>`
|
|
|
|
.. rst-class:: classref-property-setget
|
|
|
|
- |void| **set_unicode**\ (\ value\: :ref:`int<class_int>`\ )
|
|
- :ref:`int<class_int>` **get_unicode**\ (\ )
|
|
|
|
The key Unicode character code (when relevant), shifted by modifier keys. Unicode character codes for composite characters and complex scripts may not be available unless IME input mode is active. See :ref:`Window.set_ime_active()<class_Window_method_set_ime_active>` for more information. Unicode character codes are meant for text input.
|
|
|
|
\ **Note:** This property is set by the engine only for a pressed event. If the event is sent by an IME or a virtual keyboard, no corresponding key released event is sent.
|
|
|
|
.. rst-class:: classref-section-separator
|
|
|
|
----
|
|
|
|
.. rst-class:: classref-descriptions-group
|
|
|
|
Descripciones de Métodos
|
|
------------------------------------------------
|
|
|
|
.. _class_InputEventKey_method_as_text_key_label:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`String<class_String>` **as_text_key_label**\ (\ ) |const| :ref:`🔗<class_InputEventKey_method_as_text_key_label>`
|
|
|
|
Devuelve una representación :ref:`String<class_String>` de la :ref:`key_label<class_InputEventKey_property_key_label>` y los modificadores del evento.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_InputEventKey_method_as_text_keycode:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`String<class_String>` **as_text_keycode**\ (\ ) |const| :ref:`🔗<class_InputEventKey_method_as_text_keycode>`
|
|
|
|
Devuelve una representación :ref:`String<class_String>` de la :ref:`keycode<class_InputEventKey_property_keycode>` y los modificadores del evento.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_InputEventKey_method_as_text_location:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`String<class_String>` **as_text_location**\ (\ ) |const| :ref:`🔗<class_InputEventKey_method_as_text_location>`
|
|
|
|
Returns a :ref:`String<class_String>` representation of the event's :ref:`location<class_InputEventKey_property_location>`. This will be a blank string if the event is not specific to a location.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_InputEventKey_method_as_text_physical_keycode:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`String<class_String>` **as_text_physical_keycode**\ (\ ) |const| :ref:`🔗<class_InputEventKey_method_as_text_physical_keycode>`
|
|
|
|
Returns a :ref:`String<class_String>` representation of the event's :ref:`physical_keycode<class_InputEventKey_property_physical_keycode>` and modifiers.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_InputEventKey_method_get_key_label_with_modifiers:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Key<enum_@GlobalScope_Key>` **get_key_label_with_modifiers**\ (\ ) |const| :ref:`🔗<class_InputEventKey_method_get_key_label_with_modifiers>`
|
|
|
|
Returns the localized key label combined with modifier keys such as :kbd:`Shift` or :kbd:`Alt`. See also :ref:`InputEventWithModifiers<class_InputEventWithModifiers>`.
|
|
|
|
To get a human-readable representation of the **InputEventKey** with modifiers, use ``OS.get_keycode_string(event.get_key_label_with_modifiers())`` where ``event`` is the **InputEventKey**.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_InputEventKey_method_get_keycode_with_modifiers:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Key<enum_@GlobalScope_Key>` **get_keycode_with_modifiers**\ (\ ) |const| :ref:`🔗<class_InputEventKey_method_get_keycode_with_modifiers>`
|
|
|
|
Returns the Latin keycode combined with modifier keys such as :kbd:`Shift` or :kbd:`Alt`. See also :ref:`InputEventWithModifiers<class_InputEventWithModifiers>`.
|
|
|
|
To get a human-readable representation of the **InputEventKey** with modifiers, use ``OS.get_keycode_string(event.get_keycode_with_modifiers())`` where ``event`` is the **InputEventKey**.
|
|
|
|
.. rst-class:: classref-item-separator
|
|
|
|
----
|
|
|
|
.. _class_InputEventKey_method_get_physical_keycode_with_modifiers:
|
|
|
|
.. rst-class:: classref-method
|
|
|
|
:ref:`Key<enum_@GlobalScope_Key>` **get_physical_keycode_with_modifiers**\ (\ ) |const| :ref:`🔗<class_InputEventKey_method_get_physical_keycode_with_modifiers>`
|
|
|
|
Returns the physical keycode combined with modifier keys such as :kbd:`Shift` or :kbd:`Alt`. See also :ref:`InputEventWithModifiers<class_InputEventWithModifiers>`.
|
|
|
|
To get a human-readable representation of the **InputEventKey** with modifiers, use ``OS.get_keycode_string(event.get_physical_keycode_with_modifiers())`` where ``event`` is the **InputEventKey**.
|
|
|
|
.. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)`
|
|
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
|
|
.. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)`
|
|
.. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)`
|
|
.. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)`
|
|
.. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)`
|
|
.. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)`
|
|
.. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)`
|
|
.. |void| replace:: :abbr:`void (Sin valor de retorno.)`
|