godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/ru/class_control.rst
Rémi Verschelde c3f2364c10 Sync classref with 4.6 branch 
Lots of translations invalidated (fuzzied) as we just synced Weblate.
2025-12-19 16:39:51 +01:00

3826 lines
285 KiB
ReStructuredText
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. _class_Control:
Control
=======
**Наследует:** :ref:`CanvasItem<class_CanvasItem>` **<** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
**Наследуется от:** :ref:`BaseButton<class_BaseButton>`, :ref:`ColorRect<class_ColorRect>`, :ref:`Container<class_Container>`, :ref:`GraphEdit<class_GraphEdit>`, :ref:`ItemList<class_ItemList>`, :ref:`Label<class_Label>`, :ref:`LineEdit<class_LineEdit>`, :ref:`MenuBar<class_MenuBar>`, :ref:`NinePatchRect<class_NinePatchRect>`, :ref:`Panel<class_Panel>`, :ref:`Range<class_Range>`, :ref:`ReferenceRect<class_ReferenceRect>`, :ref:`RichTextLabel<class_RichTextLabel>`, :ref:`Separator<class_Separator>`, :ref:`TabBar<class_TabBar>`, :ref:`TextEdit<class_TextEdit>`, :ref:`TextureRect<class_TextureRect>`, :ref:`Tree<class_Tree>`, :ref:`VideoStreamPlayer<class_VideoStreamPlayer>`
Базовый класс для всех элементов управления GUI. Адаптирует свое положение и размер на основе родительского элемента управления.
.. rst-class:: classref-introduction-group
Описание
----------------
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 :ref:`Container<class_Container>` nodes.
\ **Note:** Since both :ref:`Node2D<class_Node2D>` and **Control** inherit from :ref:`CanvasItem<class_CanvasItem>`, they share several concepts from the class such as the :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` and :ref:`CanvasItem.visible<class_CanvasItem_property_visible>` properties.
\ **User Interface nodes and input**\
Godot propagates input events via viewports. Each :ref:`Viewport<class_Viewport>` is responsible for propagating :ref:`InputEvent<class_InputEvent>`\ s to their child nodes. As the :ref:`SceneTree.root<class_SceneTree_property_root>` is a :ref:`Window<class_Window>`, this already happens automatically for all UI elements in your game.
Input events are propagated through the :ref:`SceneTree<class_SceneTree>` from the root node to all child nodes by calling :ref:`Node._input()<class_Node_private_method__input>`. For UI elements specifically, it makes more sense to override the virtual method :ref:`_gui_input()<class_Control_private_method__gui_input>`, which filters out unrelated input events, such as by checking z-order, :ref:`mouse_filter<class_Control_property_mouse_filter>`, focus, or if the event was inside of the control's bounding box.
Call :ref:`accept_event()<class_Control_method_accept_event>` so no other node receives the event. Once you accept an input, it becomes handled so :ref:`Node._unhandled_input()<class_Node_private_method__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 :ref:`grab_focus()<class_Control_method_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 :ref:`grab_focus()<class_Control_method_grab_focus>`.
Set :ref:`mouse_filter<class_Control_property_mouse_filter>` to :ref:`MOUSE_FILTER_IGNORE<class_Control_constant_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.
\ :ref:`Theme<class_Theme>` resources change the control's appearance. The :ref:`theme<class_Control_property_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 :ref:`add_theme_font_override()<class_Control_method_add_theme_font_override>`. You can also override theme items in the Inspector.
\ **Note:** Theme items are *not* :ref:`Object<class_Object>` properties. This means you can't access their values using :ref:`Object.get()<class_Object_method_get>` and :ref:`Object.set()<class_Object_method_set>`. Instead, use the ``get_theme_*`` and ``add_theme_*_override`` methods provided by this class.
.. rst-class:: classref-introduction-group
Обучающие материалы
--------------------------------------
- :doc:`Каталог документации GUI <../tutorials/ui/index>`
- :doc:`Индивидуальный рисунок в 2D <../tutorials/2d/custom_drawing_in_2d>`
- :doc:`Галерея узлов управления <../tutorials/ui/control_node_gallery>`
- :doc:`Несколько резолюций <../tutorials/rendering/multiple_resolutions>`
- `Демоверсии всех GUI <https://github.com/godotengine/godot-demo-projects/tree/master/gui>`__
.. rst-class:: classref-reftable-group
Свойства
----------------
.. table::
:widths: auto
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\] | :ref:`accessibility_controls_nodes<class_Control_property_accessibility_controls_nodes>` | ``[]`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\] | :ref:`accessibility_described_by_nodes<class_Control_property_accessibility_described_by_nodes>` | ``[]`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`accessibility_description<class_Control_property_accessibility_description>` | ``""`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\] | :ref:`accessibility_flow_to_nodes<class_Control_property_accessibility_flow_to_nodes>` | ``[]`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\] | :ref:`accessibility_labeled_by_nodes<class_Control_property_accessibility_labeled_by_nodes>` | ``[]`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`AccessibilityLiveMode<enum_DisplayServer_AccessibilityLiveMode>` | :ref:`accessibility_live<class_Control_property_accessibility_live>` | ``0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`accessibility_name<class_Control_property_accessibility_name>` | ``""`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`anchor_bottom<class_Control_property_anchor_bottom>` | ``0.0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`anchor_left<class_Control_property_anchor_left>` | ``0.0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`anchor_right<class_Control_property_anchor_right>` | ``0.0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`anchor_top<class_Control_property_anchor_top>` | ``0.0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`auto_translate<class_Control_property_auto_translate>` | |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`clip_contents<class_Control_property_clip_contents>` | ``false`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`custom_minimum_size<class_Control_property_custom_minimum_size>` | ``Vector2(0, 0)`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`FocusBehaviorRecursive<enum_Control_FocusBehaviorRecursive>` | :ref:`focus_behavior_recursive<class_Control_property_focus_behavior_recursive>` | ``0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`FocusMode<enum_Control_FocusMode>` | :ref:`focus_mode<class_Control_property_focus_mode>` | ``0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`NodePath<class_NodePath>` | :ref:`focus_neighbor_bottom<class_Control_property_focus_neighbor_bottom>` | ``NodePath("")`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`NodePath<class_NodePath>` | :ref:`focus_neighbor_left<class_Control_property_focus_neighbor_left>` | ``NodePath("")`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`NodePath<class_NodePath>` | :ref:`focus_neighbor_right<class_Control_property_focus_neighbor_right>` | ``NodePath("")`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`NodePath<class_NodePath>` | :ref:`focus_neighbor_top<class_Control_property_focus_neighbor_top>` | ``NodePath("")`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`NodePath<class_NodePath>` | :ref:`focus_next<class_Control_property_focus_next>` | ``NodePath("")`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`NodePath<class_NodePath>` | :ref:`focus_previous<class_Control_property_focus_previous>` | ``NodePath("")`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`global_position<class_Control_property_global_position>` | |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`GrowDirection<enum_Control_GrowDirection>` | :ref:`grow_horizontal<class_Control_property_grow_horizontal>` | ``1`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`GrowDirection<enum_Control_GrowDirection>` | :ref:`grow_vertical<class_Control_property_grow_vertical>` | ``1`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`LayoutDirection<enum_Control_LayoutDirection>` | :ref:`layout_direction<class_Control_property_layout_direction>` | ``0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`localize_numeral_system<class_Control_property_localize_numeral_system>` | ``true`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`MouseBehaviorRecursive<enum_Control_MouseBehaviorRecursive>` | :ref:`mouse_behavior_recursive<class_Control_property_mouse_behavior_recursive>` | ``0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`CursorShape<enum_Control_CursorShape>` | :ref:`mouse_default_cursor_shape<class_Control_property_mouse_default_cursor_shape>` | ``0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`MouseFilter<enum_Control_MouseFilter>` | :ref:`mouse_filter<class_Control_property_mouse_filter>` | ``0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`mouse_force_pass_scroll_events<class_Control_property_mouse_force_pass_scroll_events>` | ``true`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`offset_bottom<class_Control_property_offset_bottom>` | ``0.0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`offset_left<class_Control_property_offset_left>` | ``0.0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`offset_right<class_Control_property_offset_right>` | ``0.0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`offset_top<class_Control_property_offset_top>` | ``0.0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`PhysicsInterpolationMode<enum_Node_PhysicsInterpolationMode>` | physics_interpolation_mode | ``2`` (overrides :ref:`Node<class_Node_property_physics_interpolation_mode>`) |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`pivot_offset<class_Control_property_pivot_offset>` | ``Vector2(0, 0)`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`pivot_offset_ratio<class_Control_property_pivot_offset_ratio>` | ``Vector2(0, 0)`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`position<class_Control_property_position>` | ``Vector2(0, 0)`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`rotation<class_Control_property_rotation>` | ``0.0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`rotation_degrees<class_Control_property_rotation_degrees>` | |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`scale<class_Control_property_scale>` | ``Vector2(1, 1)`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Node<class_Node>` | :ref:`shortcut_context<class_Control_property_shortcut_context>` | |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`size<class_Control_property_size>` | ``Vector2(0, 0)`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| |bitfield|\[:ref:`SizeFlags<enum_Control_SizeFlags>`\] | :ref:`size_flags_horizontal<class_Control_property_size_flags_horizontal>` | ``1`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`size_flags_stretch_ratio<class_Control_property_size_flags_stretch_ratio>` | ``1.0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| |bitfield|\[:ref:`SizeFlags<enum_Control_SizeFlags>`\] | :ref:`size_flags_vertical<class_Control_property_size_flags_vertical>` | ``1`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Theme<class_Theme>` | :ref:`theme<class_Control_property_theme>` | |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`StringName<class_StringName>` | :ref:`theme_type_variation<class_Control_property_theme_type_variation>` | ``&""`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`AutoTranslateMode<enum_Node_AutoTranslateMode>` | :ref:`tooltip_auto_translate_mode<class_Control_property_tooltip_auto_translate_mode>` | ``0`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`tooltip_text<class_Control_property_tooltip_text>` | ``""`` |
+------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Методы
------------
.. table::
:widths: auto
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`_accessibility_get_contextual_info<class_Control_private_method__accessibility_get_contextual_info>`\ (\ ) |virtual| |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`_can_drop_data<class_Control_private_method__can_drop_data>`\ (\ at_position\: :ref:`Vector2<class_Vector2>`, data\: :ref:`Variant<class_Variant>`\ ) |virtual| |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`_drop_data<class_Control_private_method__drop_data>`\ (\ at_position\: :ref:`Vector2<class_Vector2>`, data\: :ref:`Variant<class_Variant>`\ ) |virtual| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`_get_accessibility_container_name<class_Control_private_method__get_accessibility_container_name>`\ (\ node\: :ref:`Node<class_Node>`\ ) |virtual| |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`_get_drag_data<class_Control_private_method__get_drag_data>`\ (\ at_position\: :ref:`Vector2<class_Vector2>`\ ) |virtual| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`_get_minimum_size<class_Control_private_method__get_minimum_size>`\ (\ ) |virtual| |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`_get_tooltip<class_Control_private_method__get_tooltip>`\ (\ at_position\: :ref:`Vector2<class_Vector2>`\ ) |virtual| |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`_gui_input<class_Control_private_method__gui_input>`\ (\ event\: :ref:`InputEvent<class_InputEvent>`\ ) |virtual| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`_has_point<class_Control_private_method__has_point>`\ (\ point\: :ref:`Vector2<class_Vector2>`\ ) |virtual| |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Object<class_Object>` | :ref:`_make_custom_tooltip<class_Control_private_method__make_custom_tooltip>`\ (\ for_text\: :ref:`String<class_String>`\ ) |virtual| |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`Vector3i<class_Vector3i>`\] | :ref:`_structured_text_parser<class_Control_private_method__structured_text_parser>`\ (\ args\: :ref:`Array<class_Array>`, text\: :ref:`String<class_String>`\ ) |virtual| |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`accept_event<class_Control_method_accept_event>`\ (\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`accessibility_drag<class_Control_method_accessibility_drag>`\ (\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`accessibility_drop<class_Control_method_accessibility_drop>`\ (\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`add_theme_color_override<class_Control_method_add_theme_color_override>`\ (\ name\: :ref:`StringName<class_StringName>`, color\: :ref:`Color<class_Color>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`add_theme_constant_override<class_Control_method_add_theme_constant_override>`\ (\ name\: :ref:`StringName<class_StringName>`, constant\: :ref:`int<class_int>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`add_theme_font_override<class_Control_method_add_theme_font_override>`\ (\ name\: :ref:`StringName<class_StringName>`, font\: :ref:`Font<class_Font>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`add_theme_font_size_override<class_Control_method_add_theme_font_size_override>`\ (\ name\: :ref:`StringName<class_StringName>`, font_size\: :ref:`int<class_int>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`add_theme_icon_override<class_Control_method_add_theme_icon_override>`\ (\ name\: :ref:`StringName<class_StringName>`, texture\: :ref:`Texture2D<class_Texture2D>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`add_theme_stylebox_override<class_Control_method_add_theme_stylebox_override>`\ (\ name\: :ref:`StringName<class_StringName>`, stylebox\: :ref:`StyleBox<class_StyleBox>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`begin_bulk_theme_override<class_Control_method_begin_bulk_theme_override>`\ (\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`end_bulk_theme_override<class_Control_method_end_bulk_theme_override>`\ (\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Control<class_Control>` | :ref:`find_next_valid_focus<class_Control_method_find_next_valid_focus>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Control<class_Control>` | :ref:`find_prev_valid_focus<class_Control_method_find_prev_valid_focus>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Control<class_Control>` | :ref:`find_valid_focus_neighbor<class_Control_method_find_valid_focus_neighbor>`\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`force_drag<class_Control_method_force_drag>`\ (\ data\: :ref:`Variant<class_Variant>`, preview\: :ref:`Control<class_Control>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_anchor<class_Control_method_get_anchor>`\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_begin<class_Control_method_get_begin>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_combined_minimum_size<class_Control_method_get_combined_minimum_size>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_combined_pivot_offset<class_Control_method_get_combined_pivot_offset>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`CursorShape<enum_Control_CursorShape>` | :ref:`get_cursor_shape<class_Control_method_get_cursor_shape>`\ (\ position\: :ref:`Vector2<class_Vector2>` = Vector2(0, 0)\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_end<class_Control_method_get_end>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`FocusMode<enum_Control_FocusMode>` | :ref:`get_focus_mode_with_override<class_Control_method_get_focus_mode_with_override>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`NodePath<class_NodePath>` | :ref:`get_focus_neighbor<class_Control_method_get_focus_neighbor>`\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Rect2<class_Rect2>` | :ref:`get_global_rect<class_Control_method_get_global_rect>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_minimum_size<class_Control_method_get_minimum_size>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`MouseFilter<enum_Control_MouseFilter>` | :ref:`get_mouse_filter_with_override<class_Control_method_get_mouse_filter_with_override>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_offset<class_Control_method_get_offset>`\ (\ offset\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_parent_area_size<class_Control_method_get_parent_area_size>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Control<class_Control>` | :ref:`get_parent_control<class_Control_method_get_parent_control>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Rect2<class_Rect2>` | :ref:`get_rect<class_Control_method_get_rect>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_screen_position<class_Control_method_get_screen_position>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`get_theme_color<class_Control_method_get_theme_color>`\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_theme_constant<class_Control_method_get_theme_constant>`\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_theme_default_base_scale<class_Control_method_get_theme_default_base_scale>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Font<class_Font>` | :ref:`get_theme_default_font<class_Control_method_get_theme_default_font>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_theme_default_font_size<class_Control_method_get_theme_default_font_size>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Font<class_Font>` | :ref:`get_theme_font<class_Control_method_get_theme_font>`\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_theme_font_size<class_Control_method_get_theme_font_size>`\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Texture2D<class_Texture2D>` | :ref:`get_theme_icon<class_Control_method_get_theme_icon>`\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`StyleBox<class_StyleBox>` | :ref:`get_theme_stylebox<class_Control_method_get_theme_stylebox>`\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_tooltip<class_Control_method_get_tooltip>`\ (\ at_position\: :ref:`Vector2<class_Vector2>` = Vector2(0, 0)\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`grab_click_focus<class_Control_method_grab_click_focus>`\ (\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`grab_focus<class_Control_method_grab_focus>`\ (\ hide_focus\: :ref:`bool<class_bool>` = false\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_focus<class_Control_method_has_focus>`\ (\ ignore_hidden_focus\: :ref:`bool<class_bool>` = false\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_theme_color<class_Control_method_has_theme_color>`\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_theme_color_override<class_Control_method_has_theme_color_override>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_theme_constant<class_Control_method_has_theme_constant>`\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_theme_constant_override<class_Control_method_has_theme_constant_override>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_theme_font<class_Control_method_has_theme_font>`\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_theme_font_override<class_Control_method_has_theme_font_override>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_theme_font_size<class_Control_method_has_theme_font_size>`\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_theme_font_size_override<class_Control_method_has_theme_font_size_override>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_theme_icon<class_Control_method_has_theme_icon>`\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_theme_icon_override<class_Control_method_has_theme_icon_override>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_theme_stylebox<class_Control_method_has_theme_stylebox>`\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_theme_stylebox_override<class_Control_method_has_theme_stylebox_override>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_drag_successful<class_Control_method_is_drag_successful>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_layout_rtl<class_Control_method_is_layout_rtl>`\ (\ ) |const| |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`release_focus<class_Control_method_release_focus>`\ (\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`remove_theme_color_override<class_Control_method_remove_theme_color_override>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`remove_theme_constant_override<class_Control_method_remove_theme_constant_override>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`remove_theme_font_override<class_Control_method_remove_theme_font_override>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`remove_theme_font_size_override<class_Control_method_remove_theme_font_size_override>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`remove_theme_icon_override<class_Control_method_remove_theme_icon_override>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`remove_theme_stylebox_override<class_Control_method_remove_theme_stylebox_override>`\ (\ name\: :ref:`StringName<class_StringName>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`reset_size<class_Control_method_reset_size>`\ (\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_anchor<class_Control_method_set_anchor>`\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, anchor\: :ref:`float<class_float>`, keep_offset\: :ref:`bool<class_bool>` = false, push_opposite_anchor\: :ref:`bool<class_bool>` = true\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_anchor_and_offset<class_Control_method_set_anchor_and_offset>`\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, anchor\: :ref:`float<class_float>`, offset\: :ref:`float<class_float>`, push_opposite_anchor\: :ref:`bool<class_bool>` = false\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_anchors_and_offsets_preset<class_Control_method_set_anchors_and_offsets_preset>`\ (\ preset\: :ref:`LayoutPreset<enum_Control_LayoutPreset>`, resize_mode\: :ref:`LayoutPresetMode<enum_Control_LayoutPresetMode>` = 0, margin\: :ref:`int<class_int>` = 0\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_anchors_preset<class_Control_method_set_anchors_preset>`\ (\ preset\: :ref:`LayoutPreset<enum_Control_LayoutPreset>`, keep_offsets\: :ref:`bool<class_bool>` = false\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_begin<class_Control_method_set_begin>`\ (\ position\: :ref:`Vector2<class_Vector2>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_drag_forwarding<class_Control_method_set_drag_forwarding>`\ (\ drag_func\: :ref:`Callable<class_Callable>`, can_drop_func\: :ref:`Callable<class_Callable>`, drop_func\: :ref:`Callable<class_Callable>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_drag_preview<class_Control_method_set_drag_preview>`\ (\ control\: :ref:`Control<class_Control>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_end<class_Control_method_set_end>`\ (\ position\: :ref:`Vector2<class_Vector2>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_focus_neighbor<class_Control_method_set_focus_neighbor>`\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, neighbor\: :ref:`NodePath<class_NodePath>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_global_position<class_Control_method_set_global_position>`\ (\ position\: :ref:`Vector2<class_Vector2>`, keep_offsets\: :ref:`bool<class_bool>` = false\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_offset<class_Control_method_set_offset>`\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, offset\: :ref:`float<class_float>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_offsets_preset<class_Control_method_set_offsets_preset>`\ (\ preset\: :ref:`LayoutPreset<enum_Control_LayoutPreset>`, resize_mode\: :ref:`LayoutPresetMode<enum_Control_LayoutPresetMode>` = 0, margin\: :ref:`int<class_int>` = 0\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_position<class_Control_method_set_position>`\ (\ position\: :ref:`Vector2<class_Vector2>`, keep_offsets\: :ref:`bool<class_bool>` = false\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_size<class_Control_method_set_size>`\ (\ size\: :ref:`Vector2<class_Vector2>`, keep_offsets\: :ref:`bool<class_bool>` = false\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`update_minimum_size<class_Control_method_update_minimum_size>`\ (\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`warp_mouse<class_Control_method_warp_mouse>`\ (\ position\: :ref:`Vector2<class_Vector2>`\ ) |
+--------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Сигналы
--------------
.. _class_Control_signal_focus_entered:
.. rst-class:: classref-signal
**focus_entered**\ (\ ) :ref:`🔗<class_Control_signal_focus_entered>`
Вызывается, когда узел получает фокус.
.. rst-class:: classref-item-separator
----
.. _class_Control_signal_focus_exited:
.. rst-class:: classref-signal
**focus_exited**\ (\ ) :ref:`🔗<class_Control_signal_focus_exited>`
Выдается, когда узел теряет фокус.
.. rst-class:: classref-item-separator
----
.. _class_Control_signal_gui_input:
.. rst-class:: classref-signal
**gui_input**\ (\ event\: :ref:`InputEvent<class_InputEvent>`\ ) :ref:`🔗<class_Control_signal_gui_input>`
Вызывается, когда узел получает :ref:`InputEvent<class_InputEvent>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_signal_minimum_size_changed:
.. rst-class:: classref-signal
**minimum_size_changed**\ (\ ) :ref:`🔗<class_Control_signal_minimum_size_changed>`
Вызывается при изменении минимального размера узла.
.. rst-class:: classref-item-separator
----
.. _class_Control_signal_mouse_entered:
.. rst-class:: classref-signal
**mouse_entered**\ (\ ) :ref:`🔗<class_Control_signal_mouse_entered>`
Вызывается, когда курсор мыши попадает в видимую область элемента управления (или любого дочернего элемента управления), которая не перекрыта другими элементами управления или окнами, при условии, что его :ref:`mouse_filter<class_Control_property_mouse_filter>` позволяет событию достичь его, и независимо от того, находится ли он в фокусе в данный момент или нет.
\ **Примечание:** :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` не влияет на то, какой элемент управления получает сигнал.
.. rst-class:: classref-item-separator
----
.. _class_Control_signal_mouse_exited:
.. rst-class:: classref-signal
**mouse_exited**\ (\ ) :ref:`🔗<class_Control_signal_mouse_exited>`
Вызывается, когда курсор мыши покидает видимую область элемента управления (и всех дочерних элементов управления), которая не перекрыта другими элементами управления или окнами, при условии, что его :ref:`mouse_filter<class_Control_property_mouse_filter>` позволяет событию достичь его, и независимо от того, находится ли он в фокусе в данный момент или нет.
\ **Примечание:** :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` не влияет на то, какой элемент управления получает сигнал.
\ **Примечание:** Если вы хотите проверить, действительно ли мышь покинула область, игнорируя любые верхние узлы, вы можете использовать такой код:
::
func _on_mouse_exited():
if not Rect2(Vector2(), size).has_point(get_local_mouse_position()):
# Не зависает над областью.
.. rst-class:: classref-item-separator
----
.. _class_Control_signal_resized:
.. rst-class:: classref-signal
**resized**\ (\ ) :ref:`🔗<class_Control_signal_resized>`
Вызывается при изменении размера элемента управления.
.. rst-class:: classref-item-separator
----
.. _class_Control_signal_size_flags_changed:
.. rst-class:: classref-signal
**size_flags_changed**\ (\ ) :ref:`🔗<class_Control_signal_size_flags_changed>`
Выдается при изменении одного из флагов размера. См. :ref:`size_flags_horizontal<class_Control_property_size_flags_horizontal>` и :ref:`size_flags_vertical<class_Control_property_size_flags_vertical>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_signal_theme_changed:
.. rst-class:: classref-signal
**theme_changed**\ (\ ) :ref:`🔗<class_Control_signal_theme_changed>`
Вызывается при отправке уведомления :ref:`NOTIFICATION_THEME_CHANGED<class_Control_constant_NOTIFICATION_THEME_CHANGED>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Перечисления
------------------------
.. _enum_Control_FocusMode:
.. rst-class:: classref-enumeration
enum **FocusMode**: :ref:`🔗<enum_Control_FocusMode>`
.. _class_Control_constant_FOCUS_NONE:
.. rst-class:: classref-enumeration-constant
:ref:`FocusMode<enum_Control_FocusMode>` **FOCUS_NONE** = ``0``
Узел не может захватить фокус. Используйте с :ref:`focus_mode<class_Control_property_focus_mode>`.
.. _class_Control_constant_FOCUS_CLICK:
.. rst-class:: classref-enumeration-constant
:ref:`FocusMode<enum_Control_FocusMode>` **FOCUS_CLICK** = ``1``
Узел может захватывать фокус только по щелчкам мыши. Используйте с :ref:`focus_mode<class_Control_property_focus_mode>`.
.. _class_Control_constant_FOCUS_ALL:
.. rst-class:: classref-enumeration-constant
:ref:`FocusMode<enum_Control_FocusMode>` **FOCUS_ALL** = ``2``
Узел может захватывать фокус по щелчку мыши, используя стрелки и клавиши Tab на клавиатуре или кнопки D-pad на геймпаде. Используйте с :ref:`focus_mode<class_Control_property_focus_mode>`.
.. _class_Control_constant_FOCUS_ACCESSIBILITY:
.. rst-class:: classref-enumeration-constant
:ref:`FocusMode<enum_Control_FocusMode>` **FOCUS_ACCESSIBILITY** = ``3``
Узел может захватить фокус только когда активен экранный диктор. Используйте с :ref:`focus_mode<class_Control_property_focus_mode>`.
.. rst-class:: classref-item-separator
----
.. _enum_Control_FocusBehaviorRecursive:
.. rst-class:: classref-enumeration
enum **FocusBehaviorRecursive**: :ref:`🔗<enum_Control_FocusBehaviorRecursive>`
.. _class_Control_constant_FOCUS_BEHAVIOR_INHERITED:
.. rst-class:: classref-enumeration-constant
:ref:`FocusBehaviorRecursive<enum_Control_FocusBehaviorRecursive>` **FOCUS_BEHAVIOR_INHERITED** = ``0``
Наследует :ref:`focus_behavior_recursive<class_Control_property_focus_behavior_recursive>` от родительского элемента управления. Если родительского элемента управления нет, это то же самое, что и :ref:`FOCUS_BEHAVIOR_ENABLED<class_Control_constant_FOCUS_BEHAVIOR_ENABLED>`.
.. _class_Control_constant_FOCUS_BEHAVIOR_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`FocusBehaviorRecursive<enum_Control_FocusBehaviorRecursive>` **FOCUS_BEHAVIOR_DISABLED** = ``1``
Предотвращает фокусировку элемента управления. :ref:`get_focus_mode_with_override()<class_Control_method_get_focus_mode_with_override>` вернет :ref:`FOCUS_NONE<class_Control_constant_FOCUS_NONE>`.
.. _class_Control_constant_FOCUS_BEHAVIOR_ENABLED:
.. rst-class:: classref-enumeration-constant
:ref:`FocusBehaviorRecursive<enum_Control_FocusBehaviorRecursive>` **FOCUS_BEHAVIOR_ENABLED** = ``2``
Позволяет фокусировать элемент управления в зависимости от :ref:`focus_mode<class_Control_property_focus_mode>`. Это можно использовать для игнорирования :ref:`focus_behavior_recursive<class_Control_property_focus_behavior_recursive>` родительского элемента. :ref:`get_focus_mode_with_override()<class_Control_method_get_focus_mode_with_override>` вернет :ref:`focus_mode<class_Control_property_focus_mode>`.
.. rst-class:: classref-item-separator
----
.. _enum_Control_MouseBehaviorRecursive:
.. rst-class:: classref-enumeration
enum **MouseBehaviorRecursive**: :ref:`🔗<enum_Control_MouseBehaviorRecursive>`
.. _class_Control_constant_MOUSE_BEHAVIOR_INHERITED:
.. rst-class:: classref-enumeration-constant
:ref:`MouseBehaviorRecursive<enum_Control_MouseBehaviorRecursive>` **MOUSE_BEHAVIOR_INHERITED** = ``0``
Наследует :ref:`mouse_behavior_recursive<class_Control_property_mouse_behavior_recursive>` от родительского элемента управления. Если родительского элемента управления нет, это то же самое, что и :ref:`MOUSE_BEHAVIOR_ENABLED<class_Control_constant_MOUSE_BEHAVIOR_ENABLED>`.
.. _class_Control_constant_MOUSE_BEHAVIOR_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`MouseBehaviorRecursive<enum_Control_MouseBehaviorRecursive>` **MOUSE_BEHAVIOR_DISABLED** = ``1``
Запрещает элементу управления получать ввод с мыши. :ref:`get_mouse_filter_with_override()<class_Control_method_get_mouse_filter_with_override>` вернет :ref:`MOUSE_FILTER_IGNORE<class_Control_constant_MOUSE_FILTER_IGNORE>`.
.. _class_Control_constant_MOUSE_BEHAVIOR_ENABLED:
.. rst-class:: classref-enumeration-constant
:ref:`MouseBehaviorRecursive<enum_Control_MouseBehaviorRecursive>` **MOUSE_BEHAVIOR_ENABLED** = ``2``
Allows the control to receive mouse input, depending on the :ref:`mouse_filter<class_Control_property_mouse_filter>`. This can be used to ignore the parent's :ref:`mouse_behavior_recursive<class_Control_property_mouse_behavior_recursive>`. :ref:`get_mouse_filter_with_override()<class_Control_method_get_mouse_filter_with_override>` will return the :ref:`mouse_filter<class_Control_property_mouse_filter>`.
.. rst-class:: classref-item-separator
----
.. _enum_Control_CursorShape:
.. rst-class:: classref-enumeration
enum **CursorShape**: :ref:`🔗<enum_Control_CursorShape>`
.. _class_Control_constant_CURSOR_ARROW:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_ARROW** = ``0``
Показывать системный курсор мыши в виде стрелки, когда пользователь наводит курсор на узел. Использовать с :ref:`mouse_default_cursor_shape<class_Control_property_mouse_default_cursor_shape>`.
.. _class_Control_constant_CURSOR_IBEAM:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_IBEAM** = ``1``
Показывать системный I-образный курсор мыши, когда пользователь наводит курсор на узел. I-образный указатель имеет форму, похожую на "I". Он сообщает пользователю, что он может выделить или вставить текст.
.. _class_Control_constant_CURSOR_POINTING_HAND:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_POINTING_HAND** = ``2``
Показывать курсор мыши в виде указывающей руки системы, когда пользователь наводит курсор на узел.
.. _class_Control_constant_CURSOR_CROSS:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_CROSS** = ``3``
Показывать системный курсор мыши в виде крестика, когда пользователь наводит курсор на узел.
.. _class_Control_constant_CURSOR_WAIT:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_WAIT** = ``4``
Показывать курсор мыши ожидания системы, когда пользователь наводит курсор на узел. Часто песочные часы.
.. _class_Control_constant_CURSOR_BUSY:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_BUSY** = ``5``
Показывать занятый курсор мыши системы, когда пользователь наводит его на узел. Часто стрелка с маленькими песочными часами.
.. _class_Control_constant_CURSOR_DRAG:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_DRAG** = ``6``
Показывать системный курсор мыши для перетаскивания, часто сжатый кулак или символ креста, когда пользователь наводит курсор на узел. Он сообщает пользователю, что в данный момент он перетаскивает элемент, например узел в доке сцены.
.. _class_Control_constant_CURSOR_CAN_DROP:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_CAN_DROP** = ``7``
Показывать системный курсор мыши, когда пользователь наводит курсор на узел. Это может быть открытая ладонь. Он сообщает пользователю, что он может отпустить элемент, который он в данный момент захватывает, например, узел в доке сцены.
.. _class_Control_constant_CURSOR_FORBIDDEN:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_FORBIDDEN** = ``8``
Показывать запрещенный системой курсор мыши, когда пользователь наводит его на узел. Часто перечеркнутый круг.
.. _class_Control_constant_CURSOR_VSIZE:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_VSIZE** = ``9``
Показывать вертикальный курсор мыши системы изменения размера, когда пользователь наводит его на узел. Двунаправленная вертикальная стрелка. Она сообщает пользователю, что он может изменять размер окна или панели по вертикали.
.. _class_Control_constant_CURSOR_HSIZE:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_HSIZE** = ``10``
Показывать горизонтальный курсор мыши системы изменения размера, когда пользователь наводит его на узел. Двунаправленная горизонтальная стрелка. Она сообщает пользователю, что он может изменять размер окна или панели по горизонтали.
.. _class_Control_constant_CURSOR_BDIAGSIZE:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_BDIAGSIZE** = ``11``
Показывать курсор мыши для изменения размера окна системы, когда пользователь наводит его на узел. Курсор — это двунаправленная стрелка, которая идет из нижнего левого угла в верхний правый угол. Он сообщает пользователю, что он может изменять размер окна или панели как по горизонтали, так и по вертикали.
.. _class_Control_constant_CURSOR_FDIAGSIZE:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_FDIAGSIZE** = ``12``
Показывать курсор мыши для изменения размера окна системы, когда пользователь наводит его на узел. Курсор — это двунаправленная стрелка, которая идет из верхнего левого угла в нижний правый угол, противоположность :ref:`CURSOR_BDIAGSIZE<class_Control_constant_CURSOR_BDIAGSIZE>`. Он сообщает пользователю, что он может изменять размер окна или панели как по горизонтали, так и по вертикали.
.. _class_Control_constant_CURSOR_MOVE:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_MOVE** = ``13``
Показывать курсор мыши перемещения системы, когда пользователь наводит его на узел. Он показывает 2 двунаправленные стрелки под углом 90 градусов. Он сообщает пользователю, что он может свободно перемещать элемент пользовательского интерфейса.
.. _class_Control_constant_CURSOR_VSPLIT:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_VSPLIT** = ``14``
Показывать вертикальный разделенный курсор мыши системы, когда пользователь наводит курсор на узел. В Windows это то же самое, что и :ref:`CURSOR_VSIZE<class_Control_constant_CURSOR_VSIZE>`.
.. _class_Control_constant_CURSOR_HSPLIT:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_HSPLIT** = ``15``
Показывать горизонтальный разделенный курсор мыши системы, когда пользователь наводит курсор на узел. В Windows это то же самое, что и :ref:`CURSOR_HSIZE<class_Control_constant_CURSOR_HSIZE>`.
.. _class_Control_constant_CURSOR_HELP:
.. rst-class:: classref-enumeration-constant
:ref:`CursorShape<enum_Control_CursorShape>` **CURSOR_HELP** = ``16``
Показывать системную справку: курсор мыши при наведении на узел - вопросительный знак.
.. rst-class:: classref-item-separator
----
.. _enum_Control_LayoutPreset:
.. rst-class:: classref-enumeration
enum **LayoutPreset**: :ref:`🔗<enum_Control_LayoutPreset>`
.. _class_Control_constant_PRESET_TOP_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_TOP_LEFT** = ``0``
Прикрепить все 4 якоря к верхнему левому углу границ родительского элемента управления. Использовать с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_TOP_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_TOP_RIGHT** = ``1``
Прикрепить все 4 якоря к правому верхнему краю границ родительского элемента управления. Использовать с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_BOTTOM_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_BOTTOM_LEFT** = ``2``
Прикрепить все 4 якоря к нижнему левому углу границ родительского элемента управления. Использовать с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_BOTTOM_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_BOTTOM_RIGHT** = ``3``
Прикрепить все 4 якоря к нижнему правому краю границ родительского элемента управления. Использовать с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_CENTER_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_CENTER_LEFT** = ``4``
Привязать все 4 якоря к центру левого края границ родительского элемента управления. Использовать с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_CENTER_TOP:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_CENTER_TOP** = ``5``
Привяжите все 4 якоря к центру верхнего края границ родительского элемента управления. Используйте с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_CENTER_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_CENTER_RIGHT** = ``6``
Привязать все 4 якоря к центру правого края границ родительского элемента управления. Использовать с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_CENTER_BOTTOM:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_CENTER_BOTTOM** = ``7``
Привяжите все 4 якоря к центру нижнего края границ родительского элемента управления. Используйте с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_CENTER:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_CENTER** = ``8``
Привязать все 4 якоря к центру границ родительского элемента управления. Использовать с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_LEFT_WIDE:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_LEFT_WIDE** = ``9``
Привязать все 4 якоря к левому краю родительского элемента управления. Левое смещение становится относительным к левому краю, а верхнее смещение — относительно верхнего левого угла родительского узла. Использовать с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_TOP_WIDE:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_TOP_WIDE** = ``10``
Привязать все 4 якоря к верхнему краю родительского элемента управления. Левое смещение становится относительно верхнего левого угла, верхнее смещение относительно верхнего края, а правое смещение относительно верхнего правого угла родительского узла. Использовать с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_RIGHT_WIDE:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_RIGHT_WIDE** = ``11``
Привязать все 4 якоря к правому краю родительского элемента управления. Правое смещение становится относительным к правому краю, а верхнее смещение — относительно верхнего правого угла родителя узла. Использовать с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_BOTTOM_WIDE:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_BOTTOM_WIDE** = ``12``
Привязать все 4 якоря к нижнему краю родительского элемента управления. Левое смещение становится относительно нижнего левого угла, нижнее смещение относительно нижнего края, а правое смещение относительно нижнего правого угла родительского узла. Использовать с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_VCENTER_WIDE:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_VCENTER_WIDE** = ``13``
Привяжите все 4 якоря к вертикальной линии, которая разрезает родительский элемент управления пополам. Используйте с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_HCENTER_WIDE:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_HCENTER_WIDE** = ``14``
Привяжите все 4 якоря к горизонтальной линии, которая разрезает родительский элемент управления пополам. Используйте с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_PRESET_FULL_RECT:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPreset<enum_Control_LayoutPreset>` **PRESET_FULL_RECT** = ``15``
Привяжите все 4 якоря к соответствующим углам родительского элемента управления. Установите все 4 смещения на 0 после применения этого пресета, и **Control** будет соответствовать своему родительскому элементу управления. Используйте с :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. rst-class:: classref-item-separator
----
.. _enum_Control_LayoutPresetMode:
.. rst-class:: classref-enumeration
enum **LayoutPresetMode**: :ref:`🔗<enum_Control_LayoutPresetMode>`
.. _class_Control_constant_PRESET_MODE_MINSIZE:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPresetMode<enum_Control_LayoutPresetMode>` **PRESET_MODE_MINSIZE** = ``0``
Размер элемента управления будет изменен до минимального.
.. _class_Control_constant_PRESET_MODE_KEEP_WIDTH:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPresetMode<enum_Control_LayoutPresetMode>` **PRESET_MODE_KEEP_WIDTH** = ``1``
Ширина элемента управления не изменится.
.. _class_Control_constant_PRESET_MODE_KEEP_HEIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPresetMode<enum_Control_LayoutPresetMode>` **PRESET_MODE_KEEP_HEIGHT** = ``2``
Высота элемента управления не изменится.
.. _class_Control_constant_PRESET_MODE_KEEP_SIZE:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutPresetMode<enum_Control_LayoutPresetMode>` **PRESET_MODE_KEEP_SIZE** = ``3``
Размер элемента управления не изменится.
.. rst-class:: classref-item-separator
----
.. _enum_Control_SizeFlags:
.. rst-class:: classref-enumeration
flags **SizeFlags**: :ref:`🔗<enum_Control_SizeFlags>`
.. _class_Control_constant_SIZE_SHRINK_BEGIN:
.. rst-class:: classref-enumeration-constant
:ref:`SizeFlags<enum_Control_SizeFlags>` **SIZE_SHRINK_BEGIN** = ``0``
Сообщает родительскому :ref:`Container<class_Container>` о необходимости выровнять узел по его началу, либо по верхнему, либо по левому краю. Это взаимоисключающе с :ref:`SIZE_FILL<class_Control_constant_SIZE_FILL>` и другими флагами размера сжатия, но может использоваться с :ref:`SIZE_EXPAND<class_Control_constant_SIZE_EXPAND>` в некоторых контейнерах. Используйте с :ref:`size_flags_horizontal<class_Control_property_size_flags_horizontal>` и :ref:`size_flags_vertical<class_Control_property_size_flags_vertical>`.
\ **Примечание:** Установка этого флага эквивалентна отсутствию флагов размера.
.. _class_Control_constant_SIZE_FILL:
.. rst-class:: classref-enumeration-constant
:ref:`SizeFlags<enum_Control_SizeFlags>` **SIZE_FILL** = ``1``
Сообщает родительскому :ref:`Container<class_Container>` расширить границы этого узла, чтобы заполнить все доступное пространство, не выталкивая другие узлы. Это взаимоисключающе с флагами размера сжатия. Используйте с :ref:`size_flags_horizontal<class_Control_property_size_flags_horizontal>` и :ref:`size_flags_vertical<class_Control_property_size_flags_vertical>`.
.. _class_Control_constant_SIZE_EXPAND:
.. rst-class:: classref-enumeration-constant
:ref:`SizeFlags<enum_Control_SizeFlags>` **SIZE_EXPAND** = ``2``
Сообщает родительскому :ref:`Container<class_Container>` разрешить этому узлу занять все доступное пространство на помеченной вами оси. Если несколько соседних узлов настроены на расширение, они будут делить пространство на основе их коэффициента растяжения. См. :ref:`size_flags_stretch_ratio<class_Control_property_size_flags_stretch_ratio>`. Используйте с :ref:`size_flags_horizontal<class_Control_property_size_flags_horizontal>` и :ref:`size_flags_vertical<class_Control_property_size_flags_vertical>`.
.. _class_Control_constant_SIZE_EXPAND_FILL:
.. rst-class:: classref-enumeration-constant
:ref:`SizeFlags<enum_Control_SizeFlags>` **SIZE_EXPAND_FILL** = ``3``
Устанавливает флаги размера узла для заполнения и расширения. См. :ref:`SIZE_FILL<class_Control_constant_SIZE_FILL>` и :ref:`SIZE_EXPAND<class_Control_constant_SIZE_EXPAND>` для получения дополнительной информации.
.. _class_Control_constant_SIZE_SHRINK_CENTER:
.. rst-class:: classref-enumeration-constant
:ref:`SizeFlags<enum_Control_SizeFlags>` **SIZE_SHRINK_CENTER** = ``4``
Сообщает родительскому :ref:`Container<class_Container>` центрировать узел в доступном пространстве. Является взаимоисключающим с :ref:`SIZE_FILL<class_Control_constant_SIZE_FILL>` и другими флагами размера сжатия, но может использоваться с :ref:`SIZE_EXPAND<class_Control_constant_SIZE_EXPAND>` в некоторых контейнерах. Используйте с :ref:`size_flags_horizontal<class_Control_property_size_flags_horizontal>` и :ref:`size_flags_vertical<class_Control_property_size_flags_vertical>`.
.. _class_Control_constant_SIZE_SHRINK_END:
.. rst-class:: classref-enumeration-constant
:ref:`SizeFlags<enum_Control_SizeFlags>` **SIZE_SHRINK_END** = ``8``
Сообщает родительскому :ref:`Container<class_Container>` о необходимости выровнять узел по его концу, либо по нижнему, либо по правому краю. Является взаимоисключающим с :ref:`SIZE_FILL<class_Control_constant_SIZE_FILL>` и другими флагами размера сжатия, но может использоваться с :ref:`SIZE_EXPAND<class_Control_constant_SIZE_EXPAND>` в некоторых контейнерах. Используйте с :ref:`size_flags_horizontal<class_Control_property_size_flags_horizontal>` и :ref:`size_flags_vertical<class_Control_property_size_flags_vertical>`.
.. rst-class:: classref-item-separator
----
.. _enum_Control_MouseFilter:
.. rst-class:: classref-enumeration
enum **MouseFilter**: :ref:`🔗<enum_Control_MouseFilter>`
.. _class_Control_constant_MOUSE_FILTER_STOP:
.. rst-class:: classref-enumeration-constant
:ref:`MouseFilter<enum_Control_MouseFilter>` **MOUSE_FILTER_STOP** = ``0``
Элемент управления будет получать события ввода движения мыши и события ввода кнопки мыши, если щелкнуть по нему через :ref:`_gui_input()<class_Control_private_method__gui_input>`. Элемент управления также будет получать сигналы :ref:`mouse_entered<class_Control_signal_mouse_entered>` и :ref:`mouse_exited<class_Control_signal_mouse_exited>`. Эти события автоматически помечаются как обработанные и не будут распространяться дальше на другие элементы управления. Это также приводит к блокировке сигналов в других элементах управления.
.. _class_Control_constant_MOUSE_FILTER_PASS:
.. rst-class:: classref-enumeration-constant
:ref:`MouseFilter<enum_Control_MouseFilter>` **MOUSE_FILTER_PASS** = ``1``
Элемент управления будет получать события ввода движения мыши и события ввода кнопки мыши, если на него нажато через :ref:`_gui_input()<class_Control_private_method__gui_input>`. Элемент управления также получит сигналы :ref:`mouse_entered<class_Control_signal_mouse_entered>` и :ref:`mouse_exited<class_Control_signal_mouse_exited>`.
Если этот элемент управления не обрабатывает событие, событие будет распространяться вверх к его родительскому элементу управления, если он есть. Событие всплывает вверх по иерархии узлов, пока не достигнет не-:ref:`CanvasItem<class_CanvasItem>`, элемента управления с :ref:`MOUSE_FILTER_STOP<class_Control_constant_MOUSE_FILTER_STOP>` или :ref:`CanvasItem<class_CanvasItem>` с включенным :ref:`CanvasItem.top_level<class_CanvasItem_property_top_level>`. Это позволит сигналам срабатывать во всех элементах управления, которых он достигает. Если ни один элемент управления не обработал его, событие будет передано в :ref:`Node._shortcut_input()<class_Node_private_method__shortcut_input>` для дальнейшей обработки.
.. _class_Control_constant_MOUSE_FILTER_IGNORE:
.. rst-class:: classref-enumeration-constant
:ref:`MouseFilter<enum_Control_MouseFilter>` **MOUSE_FILTER_IGNORE** = ``2``
Элемент управления не будет получать никаких событий ввода движения мыши или событий ввода кнопки мыши через :ref:`_gui_input()<class_Control_private_method__gui_input>`. Элемент управления также не будет получать сигналы :ref:`mouse_entered<class_Control_signal_mouse_entered>` или :ref:`mouse_exited<class_Control_signal_mouse_exited>`. Это не помешает другим элементам управления получать эти события или подавать сигналы. Проигнорированные события не будут обрабатываться автоматически. Если у дочернего элемента есть :ref:`MOUSE_FILTER_PASS<class_Control_constant_MOUSE_FILTER_PASS>` и этому элементу управления было передано событие, событие будет далее распространяться до родительского элемента управления.
\ **Примечание:** Если элемент управления получил :ref:`mouse_entered<class_Control_signal_mouse_entered>`, но не :ref:`mouse_exited<class_Control_signal_mouse_exited>`, изменение :ref:`mouse_filter<class_Control_property_mouse_filter>` на :ref:`MOUSE_FILTER_IGNORE<class_Control_constant_MOUSE_FILTER_IGNORE>` приведет к испусканию :ref:`mouse_exited<class_Control_signal_mouse_exited>`.
.. rst-class:: classref-item-separator
----
.. _enum_Control_GrowDirection:
.. rst-class:: classref-enumeration
enum **GrowDirection**: :ref:`🔗<enum_Control_GrowDirection>`
.. _class_Control_constant_GROW_DIRECTION_BEGIN:
.. rst-class:: classref-enumeration-constant
:ref:`GrowDirection<enum_Control_GrowDirection>` **GROW_DIRECTION_BEGIN** = ``0``
Элемент управления будет увеличиваться влево или вверх, если его минимальный размер изменится и станет больше текущего размера по соответствующей оси.
.. _class_Control_constant_GROW_DIRECTION_END:
.. rst-class:: classref-enumeration-constant
:ref:`GrowDirection<enum_Control_GrowDirection>` **GROW_DIRECTION_END** = ``1``
Элемент управления будет увеличиваться вправо или вниз, если его минимальный размер изменится и станет больше текущего размера по соответствующей оси.
.. _class_Control_constant_GROW_DIRECTION_BOTH:
.. rst-class:: classref-enumeration-constant
:ref:`GrowDirection<enum_Control_GrowDirection>` **GROW_DIRECTION_BOTH** = ``2``
Элемент управления будет одинаково увеличиваться в обоих направлениях, чтобы компенсировать изменение его минимального размера и увеличение его текущего размера.
.. rst-class:: classref-item-separator
----
.. _enum_Control_Anchor:
.. rst-class:: classref-enumeration
enum **Anchor**: :ref:`🔗<enum_Control_Anchor>`
.. _class_Control_constant_ANCHOR_BEGIN:
.. rst-class:: classref-enumeration-constant
:ref:`Anchor<enum_Control_Anchor>` **ANCHOR_BEGIN** = ``0``
Привязывает одну из 4 сторон якоря к началу координат ``Rect`` узла в левом верхнем углу. Используйте его с одной из переменных-членов ``anchor_*``, например :ref:`anchor_left<class_Control_property_anchor_left>`. Чтобы изменить все 4 якоря одновременно, используйте :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. _class_Control_constant_ANCHOR_END:
.. rst-class:: classref-enumeration-constant
:ref:`Anchor<enum_Control_Anchor>` **ANCHOR_END** = ``1``
Привязывает одну из 4 сторон якоря к концу ``Rect`` узла в правом нижнем углу. Используйте его с одной из переменных-членов ``anchor_*``, например :ref:`anchor_left<class_Control_property_anchor_left>`. Чтобы изменить все 4 якоря одновременно, используйте :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>`.
.. rst-class:: classref-item-separator
----
.. _enum_Control_LayoutDirection:
.. rst-class:: classref-enumeration
enum **LayoutDirection**: :ref:`🔗<enum_Control_LayoutDirection>`
.. _class_Control_constant_LAYOUT_DIRECTION_INHERITED:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutDirection<enum_Control_LayoutDirection>` **LAYOUT_DIRECTION_INHERITED** = ``0``
Автоматическое направление макета, определяемое на основе направления макета родительского элемента управления.
.. _class_Control_constant_LAYOUT_DIRECTION_APPLICATION_LOCALE:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutDirection<enum_Control_LayoutDirection>` **LAYOUT_DIRECTION_APPLICATION_LOCALE** = ``1``
Автоматическое направление макета, определяемое текущей локалью. Направление макета справа налево автоматически используется для языков, которым оно требуется, таких как арабский и иврит, но только если загружен допустимый файл перевода для данного языка (если только указанный язык не настроен как резервный в :ref:`ProjectSettings.internationalization/locale/fallback<class_ProjectSettings_property_internationalization/locale/fallback>`). Для всех других языков (или если Godot не нашел допустимый файл перевода) используется направление макета слева направо. При использовании :ref:`TextServerFallback<class_TextServerFallback>` (:ref:`ProjectSettings.internationalization/rendering/text_driver<class_ProjectSettings_property_internationalization/rendering/text_driver>`) всегда используется направление макета слева направо независимо от языка. Направление макета справа налево также можно принудительно установить с помощью :ref:`ProjectSettings.internationalization/rendering/force_right_to_left_layout_direction<class_ProjectSettings_property_internationalization/rendering/force_right_to_left_layout_direction>`.
.. _class_Control_constant_LAYOUT_DIRECTION_LTR:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutDirection<enum_Control_LayoutDirection>` **LAYOUT_DIRECTION_LTR** = ``2``
Направление макета слева направо.
.. _class_Control_constant_LAYOUT_DIRECTION_RTL:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutDirection<enum_Control_LayoutDirection>` **LAYOUT_DIRECTION_RTL** = ``3``
Направление раскладки справа налево.
.. _class_Control_constant_LAYOUT_DIRECTION_SYSTEM_LOCALE:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutDirection<enum_Control_LayoutDirection>` **LAYOUT_DIRECTION_SYSTEM_LOCALE** = ``4``
Автоматическое направление макета, определяемое системными настройками. Направление макета справа налево автоматически используется для языков, для которых оно требуется, например, для арабского и иврита, но только если загружен корректный файл перевода для данного языка. Для всех остальных языков (или если Godot не нашёл корректный файл перевода) используется направление макета слева направо. При использовании :ref:`TextServerFallback<class_TextServerFallback>` (:ref:`ProjectSettings.internationalization/rendering/text_driver<class_ProjectSettings_property_internationalization/rendering/text_driver>`) направление макета слева направо используется всегда, независимо от языка.
.. _class_Control_constant_LAYOUT_DIRECTION_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutDirection<enum_Control_LayoutDirection>` **LAYOUT_DIRECTION_MAX** = ``5``
Представляет размер перечисления :ref:`LayoutDirection<enum_Control_LayoutDirection>`.
.. _class_Control_constant_LAYOUT_DIRECTION_LOCALE:
.. rst-class:: classref-enumeration-constant
:ref:`LayoutDirection<enum_Control_LayoutDirection>` **LAYOUT_DIRECTION_LOCALE** = ``1``
**Устарело:** Use :ref:`LAYOUT_DIRECTION_APPLICATION_LOCALE<class_Control_constant_LAYOUT_DIRECTION_APPLICATION_LOCALE>` instead.
.. rst-class:: classref-item-separator
----
.. _enum_Control_TextDirection:
.. rst-class:: classref-enumeration
enum **TextDirection**: :ref:`🔗<enum_Control_TextDirection>`
.. _class_Control_constant_TEXT_DIRECTION_INHERITED:
.. rst-class:: classref-enumeration-constant
:ref:`TextDirection<enum_Control_TextDirection>` **TEXT_DIRECTION_INHERITED** = ``3``
Направление написания текста совпадает с направлением макета.
.. _class_Control_constant_TEXT_DIRECTION_AUTO:
.. rst-class:: classref-enumeration-constant
:ref:`TextDirection<enum_Control_TextDirection>` **TEXT_DIRECTION_AUTO** = ``0``
Автоматическое направление написания текста, определяемое на основе текущей локали и содержимого текста.
.. _class_Control_constant_TEXT_DIRECTION_LTR:
.. rst-class:: classref-enumeration-constant
:ref:`TextDirection<enum_Control_TextDirection>` **TEXT_DIRECTION_LTR** = ``1``
Направление написания текста слева направо.
.. _class_Control_constant_TEXT_DIRECTION_RTL:
.. rst-class:: classref-enumeration-constant
:ref:`TextDirection<enum_Control_TextDirection>` **TEXT_DIRECTION_RTL** = ``2``
Направление текста справа налево.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Константы
------------------
.. _class_Control_constant_NOTIFICATION_RESIZED:
.. rst-class:: classref-constant
**NOTIFICATION_RESIZED** = ``40`` :ref:`🔗<class_Control_constant_NOTIFICATION_RESIZED>`
Отправляется, когда узел меняет размер. Используйте :ref:`size<class_Control_property_size>`, чтобы получить новый размер.
.. _class_Control_constant_NOTIFICATION_MOUSE_ENTER:
.. rst-class:: classref-constant
**NOTIFICATION_MOUSE_ENTER** = ``41`` :ref:`🔗<class_Control_constant_NOTIFICATION_MOUSE_ENTER>`
Отправляется, когда курсор мыши попадает в видимую область элемента управления (или любого дочернего элемента управления), которая не перекрыта другими элементами управления или окнами, при условии, что его :ref:`mouse_filter<class_Control_property_mouse_filter>` позволяет событию достичь его, и независимо от того, находится ли он в фокусе в данный момент или нет.
\ **Примечание:** :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` не влияет на то, какой элемент управления получает уведомление.
См. также :ref:`NOTIFICATION_MOUSE_ENTER_SELF<class_Control_constant_NOTIFICATION_MOUSE_ENTER_SELF>`.
.. _class_Control_constant_NOTIFICATION_MOUSE_EXIT:
.. rst-class:: classref-constant
**NOTIFICATION_MOUSE_EXIT** = ``42`` :ref:`🔗<class_Control_constant_NOTIFICATION_MOUSE_EXIT>`
Отправляется, когда курсор мыши покидает видимую область элемента управления (и всех дочерних элементов управления), которая не перекрыта другими элементами управления или окнами, при условии, что его :ref:`mouse_filter<class_Control_property_mouse_filter>` позволяет событию достичь его, и независимо от того, находится ли он в фокусе в данный момент или нет.
\ **Примечание:** :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` не влияет на то, какой элемент управления получает уведомление.
См. также :ref:`NOTIFICATION_MOUSE_EXIT_SELF<class_Control_constant_NOTIFICATION_MOUSE_EXIT_SELF>`.
.. _class_Control_constant_NOTIFICATION_MOUSE_ENTER_SELF:
.. rst-class:: classref-constant
**NOTIFICATION_MOUSE_ENTER_SELF** = ``60`` :ref:`🔗<class_Control_constant_NOTIFICATION_MOUSE_ENTER_SELF>`
**Экспериментальное:** The reason this notification is sent may change in the future.
Sent when the mouse cursor enters the control's visible area, that is not occluded behind other Controls or Windows, provided its :ref:`mouse_filter<class_Control_property_mouse_filter>` lets the event reach it and regardless if it's currently focused or not.
\ **Note:** :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` doesn't affect which Control receives the notification.
См. также :ref:`NOTIFICATION_MOUSE_ENTER<class_Control_constant_NOTIFICATION_MOUSE_ENTER>`.
.. _class_Control_constant_NOTIFICATION_MOUSE_EXIT_SELF:
.. rst-class:: classref-constant
**NOTIFICATION_MOUSE_EXIT_SELF** = ``61`` :ref:`🔗<class_Control_constant_NOTIFICATION_MOUSE_EXIT_SELF>`
**Экспериментальное:** The reason this notification is sent may change in the future.
Отправляется, когда курсор мыши покидает видимую область элемента управления, которая не перекрыта другими элементами управления или окнами, при условии, что его :ref:`mouse_filter<class_Control_property_mouse_filter>` позволяет событию достичь его, и независимо от того, находится ли он в фокусе в данный момент или нет.
\ **Примечание:** :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` не влияет на то, какой элемент управления получит уведомление.
См. также :ref:`NOTIFICATION_MOUSE_EXIT<class_Control_constant_NOTIFICATION_MOUSE_EXIT>`.
.. _class_Control_constant_NOTIFICATION_FOCUS_ENTER:
.. rst-class:: classref-constant
**NOTIFICATION_FOCUS_ENTER** = ``43`` :ref:`🔗<class_Control_constant_NOTIFICATION_FOCUS_ENTER>`
Отправляется, когда узел захватывает фокус.
.. _class_Control_constant_NOTIFICATION_FOCUS_EXIT:
.. rst-class:: classref-constant
**NOTIFICATION_FOCUS_EXIT** = ``44`` :ref:`🔗<class_Control_constant_NOTIFICATION_FOCUS_EXIT>`
Sent when the node loses focus.
This notification is sent in reversed order.
.. _class_Control_constant_NOTIFICATION_THEME_CHANGED:
.. rst-class:: classref-constant
**NOTIFICATION_THEME_CHANGED** = ``45`` :ref:`🔗<class_Control_constant_NOTIFICATION_THEME_CHANGED>`
Отправляется, когда узлу необходимо обновить элементы темы. Это происходит в одном из следующих случаев:
- Свойство :ref:`theme<class_Control_property_theme>` изменено на этом узле или любом из его предков.
- Свойство :ref:`theme_type_variation<class_Control_property_theme_type_variation>` изменено на этом узле.
- Изменено одно из переопределений свойств темы узла.
- Узел входит в дерево сцены.
\ **Примечание:** В качестве оптимизации это уведомление не будет отправлено из изменений, которые происходят, пока этот узел находится вне дерева сцены. Вместо этого все обновления элементов темы могут быть применены одновременно, когда узел входит в дерево сцены.
\ **Примечание:** Это уведомление получено вместе с :ref:`Node.NOTIFICATION_ENTER_TREE<class_Node_constant_NOTIFICATION_ENTER_TREE>`, поэтому, если вы создаете сцену, дочерние узлы еще не будут инициализированы. Вы можете использовать его для настройки тем для этого узла, дочерних узлов, созданных из скрипта, или, если вы хотите получить доступ к дочерним узлам, добавленным в редакторе, убедитесь, что узел готов, используя :ref:`Node.is_node_ready()<class_Node_method_is_node_ready>`.
::
func _notification(what):
if what == NOTIFICATION_THEME_CHANGED:
if not is_node_ready():
await ready # Дождитесь сигнала готовности.
$Label.add_theme_color_override("font_color", Color.YELLOW)
.. _class_Control_constant_NOTIFICATION_SCROLL_BEGIN:
.. rst-class:: classref-constant
**NOTIFICATION_SCROLL_BEGIN** = ``47`` :ref:`🔗<class_Control_constant_NOTIFICATION_SCROLL_BEGIN>`
Отправляется, когда этот узел находится внутри :ref:`ScrollContainer<class_ScrollContainer>`, который начал прокручиваться при перетаскивании прокручиваемой области *с помощью события касания*. Это уведомление *не* отправляется при прокрутке путем перетаскивания полосы прокрутки, прокрутки колесиком мыши или прокрутки с помощью событий клавиатуры/геймпада.
\ **Примечание:** Этот сигнал выдается только на Android или iOS, или на настольных/веб-платформах, когда включен :ref:`ProjectSettings.input_devices/pointing/emulate_touch_from_mouse<class_ProjectSettings_property_input_devices/pointing/emulate_touch_from_mouse>`.
.. _class_Control_constant_NOTIFICATION_SCROLL_END:
.. rst-class:: classref-constant
**NOTIFICATION_SCROLL_END** = ``48`` :ref:`🔗<class_Control_constant_NOTIFICATION_SCROLL_END>`
Отправляется, когда этот узел находится внутри :ref:`ScrollContainer<class_ScrollContainer>`, который перестал прокручиваться при перетаскивании прокручиваемой области *событием касания*. Это уведомление *не* отправляется при прокрутке путем перетаскивания полосы прокрутки, прокрутки колесиком мыши или прокрутки с помощью событий клавиатуры/геймпада.
\ **Примечание:** Этот сигнал выдается только на Android или iOS, или на настольных/веб-платформах, когда включен :ref:`ProjectSettings.input_devices/pointing/emulate_touch_from_mouse<class_ProjectSettings_property_input_devices/pointing/emulate_touch_from_mouse>`.
.. _class_Control_constant_NOTIFICATION_LAYOUT_DIRECTION_CHANGED:
.. rst-class:: classref-constant
**NOTIFICATION_LAYOUT_DIRECTION_CHANGED** = ``49`` :ref:`🔗<class_Control_constant_NOTIFICATION_LAYOUT_DIRECTION_CHANGED>`
Отправляется, когда направление макета элемента управления изменяется с LTR или RTL или наоборот. Это уведомление распространяется на дочерние узлы Control в результате изменения :ref:`layout_direction<class_Control_property_layout_direction>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описания свойств
--------------------------------
.. _class_Control_property_accessibility_controls_nodes:
.. rst-class:: classref-property
:ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\] **accessibility_controls_nodes** = ``[]`` :ref:`🔗<class_Control_property_accessibility_controls_nodes>`
.. rst-class:: classref-property-setget
- |void| **set_accessibility_controls_nodes**\ (\ value\: :ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\]\ )
- :ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\] **get_accessibility_controls_nodes**\ (\ )
Пути к узлам, которые контролируются данным узлом.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_accessibility_described_by_nodes:
.. rst-class:: classref-property
:ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\] **accessibility_described_by_nodes** = ``[]`` :ref:`🔗<class_Control_property_accessibility_described_by_nodes>`
.. rst-class:: classref-property-setget
- |void| **set_accessibility_described_by_nodes**\ (\ value\: :ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\]\ )
- :ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\] **get_accessibility_described_by_nodes**\ (\ )
Пути к узлам, описывающие данный узел.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_accessibility_description:
.. rst-class:: classref-property
:ref:`String<class_String>` **accessibility_description** = ``""`` :ref:`🔗<class_Control_property_accessibility_description>`
.. rst-class:: classref-property-setget
- |void| **set_accessibility_description**\ (\ value\: :ref:`String<class_String>`\ )
- :ref:`String<class_String>` **get_accessibility_description**\ (\ )
Удобочитаемое описание узла, которое передается вспомогательным приложениям.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_accessibility_flow_to_nodes:
.. rst-class:: classref-property
:ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\] **accessibility_flow_to_nodes** = ``[]`` :ref:`🔗<class_Control_property_accessibility_flow_to_nodes>`
.. rst-class:: classref-property-setget
- |void| **set_accessibility_flow_to_nodes**\ (\ value\: :ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\]\ )
- :ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\] **get_accessibility_flow_to_nodes**\ (\ )
Пути к узлам, в которые впадает данный узел.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_accessibility_labeled_by_nodes:
.. rst-class:: classref-property
:ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\] **accessibility_labeled_by_nodes** = ``[]`` :ref:`🔗<class_Control_property_accessibility_labeled_by_nodes>`
.. rst-class:: classref-property-setget
- |void| **set_accessibility_labeled_by_nodes**\ (\ value\: :ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\]\ )
- :ref:`Array<class_Array>`\[:ref:`NodePath<class_NodePath>`\] **get_accessibility_labeled_by_nodes**\ (\ )
Пути к узлам, которые маркируют данный узел.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_accessibility_live:
.. rst-class:: classref-property
:ref:`AccessibilityLiveMode<enum_DisplayServer_AccessibilityLiveMode>` **accessibility_live** = ``0`` :ref:`🔗<class_Control_property_accessibility_live>`
.. rst-class:: classref-property-setget
- |void| **set_accessibility_live**\ (\ value\: :ref:`AccessibilityLiveMode<enum_DisplayServer_AccessibilityLiveMode>`\ )
- :ref:`AccessibilityLiveMode<enum_DisplayServer_AccessibilityLiveMode>` **get_accessibility_live**\ (\ )
Режим обновления активной области. Активная область — это :ref:`Node<class_Node>`, который обновляется в результате внешнего события, когда фокус пользователя может быть в другом месте.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_accessibility_name:
.. rst-class:: classref-property
:ref:`String<class_String>` **accessibility_name** = ``""`` :ref:`🔗<class_Control_property_accessibility_name>`
.. rst-class:: classref-property-setget
- |void| **set_accessibility_name**\ (\ value\: :ref:`String<class_String>`\ )
- :ref:`String<class_String>` **get_accessibility_name**\ (\ )
Удобочитаемое имя узла, которое сообщается вспомогательным приложениям.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_anchor_bottom:
.. rst-class:: classref-property
:ref:`float<class_float>` **anchor_bottom** = ``0.0`` :ref:`🔗<class_Control_property_anchor_bottom>`
.. rst-class:: classref-property-setget
- :ref:`float<class_float>` **get_anchor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Прикрепляет нижний край узла к началу координат, центру или концу его родительского элемента управления. Изменяет способ обновления нижнего смещения при перемещении узла или изменении его размера. Для удобства можно использовать одну из констант :ref:`Anchor<enum_Control_Anchor>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_anchor_left:
.. rst-class:: classref-property
:ref:`float<class_float>` **anchor_left** = ``0.0`` :ref:`🔗<class_Control_property_anchor_left>`
.. rst-class:: classref-property-setget
- :ref:`float<class_float>` **get_anchor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Привязывает левый край узла к началу координат, центру или концу его родительского элемента управления. Изменяет способ обновления левого смещения при перемещении узла или изменении размера. Для удобства можно использовать одну из констант :ref:`Anchor<enum_Control_Anchor>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_anchor_right:
.. rst-class:: classref-property
:ref:`float<class_float>` **anchor_right** = ``0.0`` :ref:`🔗<class_Control_property_anchor_right>`
.. rst-class:: classref-property-setget
- :ref:`float<class_float>` **get_anchor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Привязывает правый край узла к началу координат, центру или концу его родительского элемента управления. Изменяет способ обновления правого смещения при перемещении узла или изменении его размера. Для удобства можно использовать одну из констант :ref:`Anchor<enum_Control_Anchor>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_anchor_top:
.. rst-class:: classref-property
:ref:`float<class_float>` **anchor_top** = ``0.0`` :ref:`🔗<class_Control_property_anchor_top>`
.. rst-class:: classref-property-setget
- :ref:`float<class_float>` **get_anchor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Прикрепляет верхний край узла к началу координат, центру или концу его родительского элемента управления. Изменяет способ обновления верхнего смещения при перемещении узла или изменении его размера. Для удобства можно использовать одну из констант :ref:`Anchor<enum_Control_Anchor>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_auto_translate:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **auto_translate** :ref:`🔗<class_Control_property_auto_translate>`
.. rst-class:: classref-property-setget
- |void| **set_auto_translate**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_auto_translating**\ (\ )
**Устарело:** Use :ref:`Node.auto_translate_mode<class_Node_property_auto_translate_mode>` and :ref:`Node.can_auto_translate()<class_Node_method_can_auto_translate>` instead.
Включает/выключает автоматическую замену текста на переведенную версию в зависимости от текущей локали.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_clip_contents:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **clip_contents** = ``false`` :ref:`🔗<class_Control_property_clip_contents>`
.. rst-class:: classref-property-setget
- |void| **set_clip_contents**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_clipping_contents**\ (\ )
Включает, следует ли обрезать отрисовку дочерних элементов на основе :ref:`CanvasItem<class_CanvasItem>` до прямоугольника этого элемента управления. Если ``true``, части дочернего элемента, которые будут видны за пределами прямоугольника этого элемента управления, не будут отрисовываться и не будут получать входные данные.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_custom_minimum_size:
.. rst-class:: classref-property
:ref:`Vector2<class_Vector2>` **custom_minimum_size** = ``Vector2(0, 0)`` :ref:`🔗<class_Control_property_custom_minimum_size>`
.. rst-class:: classref-property-setget
- |void| **set_custom_minimum_size**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
- :ref:`Vector2<class_Vector2>` **get_custom_minimum_size**\ (\ )
Минимальный размер ограничивающего прямоугольника узла. Если вы установите его на значение больше, чем ``(0, 0)``, ограничивающий прямоугольник узла всегда будет иметь по крайней мере этот размер. Обратите внимание, что узлы **Control** имеют свой внутренний минимальный размер, возвращаемый :ref:`get_minimum_size()<class_Control_method_get_minimum_size>`. Он зависит от содержимого элемента управления, такого как текст, текстуры или поля стилей. Фактический минимальный размер — это максимальное значение этого свойства и внутренний минимальный размер (см. :ref:`get_combined_minimum_size()<class_Control_method_get_combined_minimum_size>`).
.. rst-class:: classref-item-separator
----
.. _class_Control_property_focus_behavior_recursive:
.. rst-class:: classref-property
:ref:`FocusBehaviorRecursive<enum_Control_FocusBehaviorRecursive>` **focus_behavior_recursive** = ``0`` :ref:`🔗<class_Control_property_focus_behavior_recursive>`
.. rst-class:: classref-property-setget
- |void| **set_focus_behavior_recursive**\ (\ value\: :ref:`FocusBehaviorRecursive<enum_Control_FocusBehaviorRecursive>`\ )
- :ref:`FocusBehaviorRecursive<enum_Control_FocusBehaviorRecursive>` **get_focus_behavior_recursive**\ (\ )
Определяет, какие элементы управления могут быть сфокусированы вместе с :ref:`focus_mode<class_Control_property_focus_mode>`. См. :ref:`get_focus_mode_with_override()<class_Control_method_get_focus_mode_with_override>`. Поскольку поведение по умолчанию — :ref:`FOCUS_BEHAVIOR_INHERITED<class_Control_constant_FOCUS_BEHAVIOR_INHERITED>`, это можно использовать для предотвращения фокусировки всех дочерних элементов управления.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_focus_mode:
.. rst-class:: classref-property
:ref:`FocusMode<enum_Control_FocusMode>` **focus_mode** = ``0`` :ref:`🔗<class_Control_property_focus_mode>`
.. rst-class:: classref-property-setget
- |void| **set_focus_mode**\ (\ value\: :ref:`FocusMode<enum_Control_FocusMode>`\ )
- :ref:`FocusMode<enum_Control_FocusMode>` **get_focus_mode**\ (\ )
Определяет, какие элементы управления могут быть сфокусированы. Только один элемент управления может быть сфокусирован одновременно, и сфокусированный элемент управления будет получать события клавиатуры, геймпада и мыши в :ref:`_gui_input()<class_Control_private_method__gui_input>`. Используйте :ref:`get_focus_mode_with_override()<class_Control_method_get_focus_mode_with_override>`, чтобы определить, может ли элемент управления захватить фокус, поскольку :ref:`focus_behavior_recursive<class_Control_property_focus_behavior_recursive>` также влияет на него. См. также :ref:`grab_focus()<class_Control_method_grab_focus>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_focus_neighbor_bottom:
.. rst-class:: classref-property
:ref:`NodePath<class_NodePath>` **focus_neighbor_bottom** = ``NodePath("")`` :ref:`🔗<class_Control_property_focus_neighbor_bottom>`
.. rst-class:: classref-property-setget
- |void| **set_focus_neighbor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, neighbor\: :ref:`NodePath<class_NodePath>`\ )
- :ref:`NodePath<class_NodePath>` **get_focus_neighbor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Сообщает Godot, какому узлу следует передать фокус, если пользователь нажимает стрелку вниз на клавиатуре или вниз на геймпаде по умолчанию. Вы можете изменить клавишу, отредактировав действие ввода :ref:`ProjectSettings.input/ui_down<class_ProjectSettings_property_input/ui_down>`. Узел должен быть **Control**. Если это свойство не задано, Godot передаст фокус ближайшему **Control** к нижней части этого.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_focus_neighbor_left:
.. rst-class:: classref-property
:ref:`NodePath<class_NodePath>` **focus_neighbor_left** = ``NodePath("")`` :ref:`🔗<class_Control_property_focus_neighbor_left>`
.. rst-class:: classref-property-setget
- |void| **set_focus_neighbor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, neighbor\: :ref:`NodePath<class_NodePath>`\ )
- :ref:`NodePath<class_NodePath>` **get_focus_neighbor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Сообщает Godot, какому узлу следует передать фокус, если пользователь нажимает левую стрелку на клавиатуре или левую на геймпаде по умолчанию. Вы можете изменить клавишу, отредактировав действие ввода :ref:`ProjectSettings.input/ui_left<class_ProjectSettings_property_input/ui_left>`. Узел должен быть **Control**. Если это свойство не задано, Godot передаст фокус ближайшему **Control** слева от этого.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_focus_neighbor_right:
.. rst-class:: classref-property
:ref:`NodePath<class_NodePath>` **focus_neighbor_right** = ``NodePath("")`` :ref:`🔗<class_Control_property_focus_neighbor_right>`
.. rst-class:: classref-property-setget
- |void| **set_focus_neighbor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, neighbor\: :ref:`NodePath<class_NodePath>`\ )
- :ref:`NodePath<class_NodePath>` **get_focus_neighbor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Сообщает Godot, какому узлу следует передать фокус, если пользователь нажимает стрелку вправо на клавиатуре или вправо на геймпаде по умолчанию. Вы можете изменить клавишу, отредактировав действие ввода :ref:`ProjectSettings.input/ui_right<class_ProjectSettings_property_input/ui_right>`. Узел должен быть **Control**. Если это свойство не задано, Godot передаст фокус ближайшему **Control** справа от этого.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_focus_neighbor_top:
.. rst-class:: classref-property
:ref:`NodePath<class_NodePath>` **focus_neighbor_top** = ``NodePath("")`` :ref:`🔗<class_Control_property_focus_neighbor_top>`
.. rst-class:: classref-property-setget
- |void| **set_focus_neighbor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, neighbor\: :ref:`NodePath<class_NodePath>`\ )
- :ref:`NodePath<class_NodePath>` **get_focus_neighbor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Сообщает Godot, какому узлу следует передать фокус, если пользователь нажимает верхнюю стрелку на клавиатуре или верхнюю на геймпаде по умолчанию. Вы можете изменить клавишу, отредактировав действие ввода :ref:`ProjectSettings.input/ui_up<class_ProjectSettings_property_input/ui_up>`. Узел должен быть **Control**. Если это свойство не задано, Godot передаст фокус ближайшему **Control** к верхней части этого.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_focus_next:
.. rst-class:: classref-property
:ref:`NodePath<class_NodePath>` **focus_next** = ``NodePath("")`` :ref:`🔗<class_Control_property_focus_next>`
.. rst-class:: classref-property-setget
- |void| **set_focus_next**\ (\ value\: :ref:`NodePath<class_NodePath>`\ )
- :ref:`NodePath<class_NodePath>` **get_focus_next**\ (\ )
Сообщает Godot, на какой узел следует направить фокус, если пользователь нажимает :kbd:`Tab` на клавиатуре по умолчанию. Вы можете изменить клавишу, отредактировав действие ввода :ref:`ProjectSettings.input/ui_focus_next<class_ProjectSettings_property_input/ui_focus_next>`.
Если это свойство не задано, Godot выберет «лучшее предположение» на основе окружающих узлов в дереве сцены.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_focus_previous:
.. rst-class:: classref-property
:ref:`NodePath<class_NodePath>` **focus_previous** = ``NodePath("")`` :ref:`🔗<class_Control_property_focus_previous>`
.. rst-class:: classref-property-setget
- |void| **set_focus_previous**\ (\ value\: :ref:`NodePath<class_NodePath>`\ )
- :ref:`NodePath<class_NodePath>` **get_focus_previous**\ (\ )
Сообщает Godot, на какой узел следует направить фокус, если пользователь нажимает :kbd:`Shift + Tab` на клавиатуре по умолчанию. Вы можете изменить клавишу, отредактировав действие ввода :ref:`ProjectSettings.input/ui_focus_prev<class_ProjectSettings_property_input/ui_focus_prev>`.
Если это свойство не задано, Godot выберет «лучшее предположение» на основе окружающих узлов в дереве сцены.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_global_position:
.. rst-class:: classref-property
:ref:`Vector2<class_Vector2>` **global_position** :ref:`🔗<class_Control_property_global_position>`
.. rst-class:: classref-property-setget
- :ref:`Vector2<class_Vector2>` **get_global_position**\ (\ )
Глобальное положение узла относительно мира (обычно по отношению к :ref:`CanvasLayer<class_CanvasLayer>`).
.. rst-class:: classref-item-separator
----
.. _class_Control_property_grow_horizontal:
.. rst-class:: classref-property
:ref:`GrowDirection<enum_Control_GrowDirection>` **grow_horizontal** = ``1`` :ref:`🔗<class_Control_property_grow_horizontal>`
.. rst-class:: classref-property-setget
- |void| **set_h_grow_direction**\ (\ value\: :ref:`GrowDirection<enum_Control_GrowDirection>`\ )
- :ref:`GrowDirection<enum_Control_GrowDirection>` **get_h_grow_direction**\ (\ )
Управляет направлением по горизонтальной оси, в котором должен увеличиваться элемент управления, если его минимальный горизонтальный размер изменяется и становится больше текущего размера, поскольку элемент управления всегда должен иметь размер не меньше минимального.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_grow_vertical:
.. rst-class:: classref-property
:ref:`GrowDirection<enum_Control_GrowDirection>` **grow_vertical** = ``1`` :ref:`🔗<class_Control_property_grow_vertical>`
.. rst-class:: classref-property-setget
- |void| **set_v_grow_direction**\ (\ value\: :ref:`GrowDirection<enum_Control_GrowDirection>`\ )
- :ref:`GrowDirection<enum_Control_GrowDirection>` **get_v_grow_direction**\ (\ )
Управляет направлением по вертикальной оси, в котором должен увеличиваться элемент управления, если его минимальный вертикальный размер изменяется и становится больше текущего размера, поскольку элемент управления всегда должен иметь размер не меньше минимального.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_layout_direction:
.. rst-class:: classref-property
:ref:`LayoutDirection<enum_Control_LayoutDirection>` **layout_direction** = ``0`` :ref:`🔗<class_Control_property_layout_direction>`
.. rst-class:: classref-property-setget
- |void| **set_layout_direction**\ (\ value\: :ref:`LayoutDirection<enum_Control_LayoutDirection>`\ )
- :ref:`LayoutDirection<enum_Control_LayoutDirection>` **get_layout_direction**\ (\ )
Управляет направлением макета и направлением написания текста. Для некоторых языков (например, арабского и иврита) необходимы макеты справа налево. См. также :ref:`is_layout_rtl()<class_Control_method_is_layout_rtl>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_localize_numeral_system:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **localize_numeral_system** = ``true`` :ref:`🔗<class_Control_property_localize_numeral_system>`
.. rst-class:: classref-property-setget
- |void| **set_localize_numeral_system**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_localizing_numeral_system**\ (\ )
Если ``true``, автоматически преобразует номера строк кода, индексы списков, значения :ref:`SpinBox<class_SpinBox>` и :ref:`ProgressBar<class_ProgressBar>` из западно-арабской системы счисления (0..9) в системы счисления, используемые в текущей локали.
\ **Примечание:** Числа в тексте не преобразуются автоматически, это можно сделать вручную, используя :ref:`TextServer.format_number()<class_TextServer_method_format_number>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_mouse_behavior_recursive:
.. rst-class:: classref-property
:ref:`MouseBehaviorRecursive<enum_Control_MouseBehaviorRecursive>` **mouse_behavior_recursive** = ``0`` :ref:`🔗<class_Control_property_mouse_behavior_recursive>`
.. rst-class:: classref-property-setget
- |void| **set_mouse_behavior_recursive**\ (\ value\: :ref:`MouseBehaviorRecursive<enum_Control_MouseBehaviorRecursive>`\ )
- :ref:`MouseBehaviorRecursive<enum_Control_MouseBehaviorRecursive>` **get_mouse_behavior_recursive**\ (\ )
Определяет, какие элементы управления могут получать ввод мыши вместе с :ref:`mouse_filter<class_Control_property_mouse_filter>`. См. :ref:`get_mouse_filter_with_override()<class_Control_method_get_mouse_filter_with_override>`. Поскольку поведение по умолчанию — :ref:`MOUSE_BEHAVIOR_INHERITED<class_Control_constant_MOUSE_BEHAVIOR_INHERITED>`, это можно использовать для предотвращения получения ввода мыши всеми дочерними элементами управления.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_mouse_default_cursor_shape:
.. rst-class:: classref-property
:ref:`CursorShape<enum_Control_CursorShape>` **mouse_default_cursor_shape** = ``0`` :ref:`🔗<class_Control_property_mouse_default_cursor_shape>`
.. rst-class:: classref-property-setget
- |void| **set_default_cursor_shape**\ (\ value\: :ref:`CursorShape<enum_Control_CursorShape>`\ )
- :ref:`CursorShape<enum_Control_CursorShape>` **get_default_cursor_shape**\ (\ )
Форма курсора по умолчанию для этого элемента управления. Полезно для плагинов Godot и приложений или игр, которые используют системные курсоры мыши.
\ **Примечание:** В Linux формы могут различаться в зависимости от темы курсора системы.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_mouse_filter:
.. rst-class:: classref-property
:ref:`MouseFilter<enum_Control_MouseFilter>` **mouse_filter** = ``0`` :ref:`🔗<class_Control_property_mouse_filter>`
.. rst-class:: classref-property-setget
- |void| **set_mouse_filter**\ (\ value\: :ref:`MouseFilter<enum_Control_MouseFilter>`\ )
- :ref:`MouseFilter<enum_Control_MouseFilter>` **get_mouse_filter**\ (\ )
Определяет, какие элементы управления смогут получать события ввода с помощью кнопки мыши через :ref:`_gui_input()<class_Control_private_method__gui_input>` и сигналы :ref:`mouse_entered<class_Control_signal_mouse_entered>` и :ref:`mouse_exited<class_Control_signal_mouse_exited>`. Также определяет, как эти события должны распространяться. См. константы, чтобы узнать, что делает каждая из них. Используйте :ref:`get_mouse_filter_with_override()<class_Control_method_get_mouse_filter_with_override>`, чтобы определить, может ли элемент управления получать ввод с помощью мыши, поскольку :ref:`mouse_behavior_recursive<class_Control_property_mouse_behavior_recursive>` также влияет на него.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_mouse_force_pass_scroll_events:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **mouse_force_pass_scroll_events** = ``true`` :ref:`🔗<class_Control_property_mouse_force_pass_scroll_events>`
.. rst-class:: classref-property-setget
- |void| **set_force_pass_scroll_events**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_force_pass_scroll_events**\ (\ )
При включении события колеса прокрутки, обработанные :ref:`_gui_input()<class_Control_private_method__gui_input>`, будут передаваться родительскому элементу управления, даже если :ref:`mouse_filter<class_Control_property_mouse_filter>` установлен на :ref:`MOUSE_FILTER_STOP<class_Control_constant_MOUSE_FILTER_STOP>`.
Вы должны отключить его в корне вашего пользовательского интерфейса, если вы не хотите, чтобы события прокрутки передавались в обработку :ref:`Node._unhandled_input()<class_Node_private_method__unhandled_input>`.
\ **Примечание:** Поскольку это свойство по умолчанию равно ``true``, это позволяет вложенным прокручиваемым контейнерам работать из коробки.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_offset_bottom:
.. rst-class:: classref-property
:ref:`float<class_float>` **offset_bottom** = ``0.0`` :ref:`🔗<class_Control_property_offset_bottom>`
.. rst-class:: classref-property-setget
- |void| **set_offset**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, offset\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_offset**\ (\ offset\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Расстояние между нижним краем узла и его родительским элементом управления, основанное на :ref:`anchor_bottom<class_Control_property_anchor_bottom>`.
Смещения часто контролируются одним или несколькими родительскими узлами :ref:`Container<class_Container>`, поэтому вам не следует изменять их вручную, если ваш узел является прямым потомком :ref:`Container<class_Container>`. Смещения обновляются автоматически при перемещении или изменении размера узла.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_offset_left:
.. rst-class:: classref-property
:ref:`float<class_float>` **offset_left** = ``0.0`` :ref:`🔗<class_Control_property_offset_left>`
.. rst-class:: classref-property-setget
- |void| **set_offset**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, offset\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_offset**\ (\ offset\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Расстояние между левым краем узла и его родительским элементом управления, основанное на :ref:`anchor_left<class_Control_property_anchor_left>`.
Смещения часто контролируются одним или несколькими родительскими узлами :ref:`Container<class_Container>`, поэтому вам не следует изменять их вручную, если ваш узел является прямым потомком :ref:`Container<class_Container>`. Смещения обновляются автоматически при перемещении или изменении размера узла.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_offset_right:
.. rst-class:: classref-property
:ref:`float<class_float>` **offset_right** = ``0.0`` :ref:`🔗<class_Control_property_offset_right>`
.. rst-class:: classref-property-setget
- |void| **set_offset**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, offset\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_offset**\ (\ offset\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Расстояние между правым краем узла и его родительским элементом управления, основанное на :ref:`anchor_right<class_Control_property_anchor_right>`.
Смещения часто контролируются одним или несколькими родительскими узлами :ref:`Container<class_Container>`, поэтому вам не следует изменять их вручную, если ваш узел является прямым потомком :ref:`Container<class_Container>`. Смещения обновляются автоматически при перемещении или изменении размера узла.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_offset_top:
.. rst-class:: classref-property
:ref:`float<class_float>` **offset_top** = ``0.0`` :ref:`🔗<class_Control_property_offset_top>`
.. rst-class:: classref-property-setget
- |void| **set_offset**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, offset\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_offset**\ (\ offset\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const|
Расстояние между верхним краем узла и его родительским элементом управления, основанное на :ref:`anchor_top<class_Control_property_anchor_top>`.
Смещения часто контролируются одним или несколькими родительскими узлами :ref:`Container<class_Container>`, поэтому вам не следует изменять их вручную, если ваш узел является прямым потомком :ref:`Container<class_Container>`. Смещения обновляются автоматически при перемещении или изменении размера узла.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_pivot_offset:
.. rst-class:: classref-property
:ref:`Vector2<class_Vector2>` **pivot_offset** = ``Vector2(0, 0)`` :ref:`🔗<class_Control_property_pivot_offset>`
.. rst-class:: classref-property-setget
- |void| **set_pivot_offset**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
- :ref:`Vector2<class_Vector2>` **get_pivot_offset**\ (\ )
By default, the node's pivot is its top-left corner. When you change its :ref:`rotation<class_Control_property_rotation>` or :ref:`scale<class_Control_property_scale>`, it will rotate or scale around this pivot.
The actual offset is the combined value of this property and :ref:`pivot_offset_ratio<class_Control_property_pivot_offset_ratio>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_pivot_offset_ratio:
.. rst-class:: classref-property
:ref:`Vector2<class_Vector2>` **pivot_offset_ratio** = ``Vector2(0, 0)`` :ref:`🔗<class_Control_property_pivot_offset_ratio>`
.. rst-class:: classref-property-setget
- |void| **set_pivot_offset_ratio**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
- :ref:`Vector2<class_Vector2>` **get_pivot_offset_ratio**\ (\ )
Same as :ref:`pivot_offset<class_Control_property_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 :ref:`pivot_offset<class_Control_property_pivot_offset>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_position:
.. rst-class:: classref-property
:ref:`Vector2<class_Vector2>` **position** = ``Vector2(0, 0)`` :ref:`🔗<class_Control_property_position>`
.. rst-class:: classref-property-setget
- :ref:`Vector2<class_Vector2>` **get_position**\ (\ )
Положение узла относительно содержащего его узла. Соответствует верхнему левому углу прямоугольника. Свойство не зависит от :ref:`pivot_offset<class_Control_property_pivot_offset>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_rotation:
.. rst-class:: classref-property
:ref:`float<class_float>` **rotation** = ``0.0`` :ref:`🔗<class_Control_property_rotation>`
.. rst-class:: classref-property-setget
- |void| **set_rotation**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_rotation**\ (\ )
Вращение узла вокруг его опорной точки в радианах. См. :ref:`pivot_offset<class_Control_property_pivot_offset>`, чтобы изменить положение опорной точки.
\ **Примечание:** Это свойство редактируется в инспекторе в градусах. Если вы хотите использовать градусы в скрипте, используйте :ref:`rotation_degrees<class_Control_property_rotation_degrees>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_rotation_degrees:
.. rst-class:: classref-property
:ref:`float<class_float>` **rotation_degrees** :ref:`🔗<class_Control_property_rotation_degrees>`
.. rst-class:: classref-property-setget
- |void| **set_rotation_degrees**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_rotation_degrees**\ (\ )
Вспомогательное свойство для доступа к :ref:`rotation<class_Control_property_rotation>` в градусах вместо радиан.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_scale:
.. rst-class:: classref-property
:ref:`Vector2<class_Vector2>` **scale** = ``Vector2(1, 1)`` :ref:`🔗<class_Control_property_scale>`
.. rst-class:: classref-property-setget
- |void| **set_scale**\ (\ value\: :ref:`Vector2<class_Vector2>`\ )
- :ref:`Vector2<class_Vector2>` **get_scale**\ (\ )
Масштаб узла относительно его :ref:`size<class_Control_property_size>`. Измените это свойство, чтобы масштабировать узел вокруг его :ref:`pivot_offset<class_Control_property_pivot_offset>`. Подсказка элемента управления также будет масштабироваться в соответствии с этим значением.
\ **Примечание:** Это свойство в основном предназначено для использования в целях анимации. Для поддержки нескольких разрешений в вашем проекте используйте соответствующий режим растяжения области просмотра, как описано в :doc:`документации <../tutorials/rendering/multiple_resolutions>`, вместо того, чтобы масштабировать элементы управления по отдельности.
\ **Примечание:** :ref:`FontFile.oversampling<class_FontFile_property_oversampling>` *не* учитывает **Control** :ref:`scale<class_Control_property_scale>`. Это означает, что масштабирование вверх/вниз приведет к тому, что растровые шрифты и растрированные (не MSDF) динамические шрифты будут выглядеть размытыми или пикселизированными. Чтобы текст оставался четким независимо от масштаба, можно включить рендеринг шрифта MSDF, включив :ref:`ProjectSettings.gui/theme/default_font_multichannel_signed_distance_field<class_ProjectSettings_property_gui/theme/default_font_multichannel_signed_distance_field>` (применяется только к шрифту проекта по умолчанию) или включив **Multichannel Signed Distance Field** в параметрах импорта DynamicFont для пользовательских шрифтов. В системных шрифтах :ref:`SystemFont.multichannel_signed_distance_field<class_SystemFont_property_multichannel_signed_distance_field>` можно включить в инспекторе.
\ **Примечание:** Если узел Control является дочерним элементом узла :ref:`Container<class_Container>`, масштаб будет сброшен до ``Vector2(1, 1)`` при создании экземпляра сцены. Чтобы задать масштаб элемента Control при его создании, подождите один кадр с помощью ``await get_tree().process_frame``, а затем задайте его свойство :ref:`scale<class_Control_property_scale>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_shortcut_context:
.. rst-class:: classref-property
:ref:`Node<class_Node>` **shortcut_context** :ref:`🔗<class_Control_property_shortcut_context>`
.. rst-class:: classref-property-setget
- |void| **set_shortcut_context**\ (\ value\: :ref:`Node<class_Node>`\ )
- :ref:`Node<class_Node>` **get_shortcut_context**\ (\ )
:ref:`Node<class_Node>`, который должен быть родителем сфокусированного **Control**, чтобы сочетание клавиш было активировано. Если ``null``, сочетание клавиш может быть активировано, когда любой элемент управления находится в фокусе (глобальное сочетание клавиш). Это позволяет принимать сочетания клавиш только тогда, когда пользователь сфокусировал определенную область графического интерфейса.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_size:
.. rst-class:: classref-property
:ref:`Vector2<class_Vector2>` **size** = ``Vector2(0, 0)`` :ref:`🔗<class_Control_property_size>`
.. rst-class:: classref-property-setget
- :ref:`Vector2<class_Vector2>` **get_size**\ (\ )
Размер ограничивающего прямоугольника узла в системе координат узла. Узлы :ref:`Container<class_Container>` обновляют это свойство автоматически.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_size_flags_horizontal:
.. rst-class:: classref-property
|bitfield|\[:ref:`SizeFlags<enum_Control_SizeFlags>`\] **size_flags_horizontal** = ``1`` :ref:`🔗<class_Control_property_size_flags_horizontal>`
.. rst-class:: classref-property-setget
- |void| **set_h_size_flags**\ (\ value\: |bitfield|\[:ref:`SizeFlags<enum_Control_SizeFlags>`\]\ )
- |bitfield|\[:ref:`SizeFlags<enum_Control_SizeFlags>`\] **get_h_size_flags**\ (\ )
Сообщает родительским узлам :ref:`Container<class_Container>`, как они должны изменить размер и разместить узел на оси X. Используйте комбинацию констант :ref:`SizeFlags<enum_Control_SizeFlags>`, чтобы изменить флаги. Посмотрите константы, чтобы узнать, что делает каждая из них.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_size_flags_stretch_ratio:
.. rst-class:: classref-property
:ref:`float<class_float>` **size_flags_stretch_ratio** = ``1.0`` :ref:`🔗<class_Control_property_size_flags_stretch_ratio>`
.. rst-class:: classref-property-setget
- |void| **set_stretch_ratio**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_stretch_ratio**\ (\ )
Если узел и хотя бы один из его соседей используют флаг размера :ref:`SIZE_EXPAND<class_Control_constant_SIZE_EXPAND>`, родительский :ref:`Container<class_Container>` позволит ему занять больше или меньше места в зависимости от этого свойства. Если этот узел имеет коэффициент растяжения 2, а его сосед — коэффициент 1, этот узел займет две трети доступного пространства.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_size_flags_vertical:
.. rst-class:: classref-property
|bitfield|\[:ref:`SizeFlags<enum_Control_SizeFlags>`\] **size_flags_vertical** = ``1`` :ref:`🔗<class_Control_property_size_flags_vertical>`
.. rst-class:: classref-property-setget
- |void| **set_v_size_flags**\ (\ value\: |bitfield|\[:ref:`SizeFlags<enum_Control_SizeFlags>`\]\ )
- |bitfield|\[:ref:`SizeFlags<enum_Control_SizeFlags>`\] **get_v_size_flags**\ (\ )
Сообщает родительским узлам :ref:`Container<class_Container>`, как они должны изменить размер и разместить узел на оси Y. Используйте комбинацию констант :ref:`SizeFlags<enum_Control_SizeFlags>`, чтобы изменить флаги. Посмотрите константы, чтобы узнать, что делает каждая из них.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_theme:
.. rst-class:: classref-property
:ref:`Theme<class_Theme>` **theme** :ref:`🔗<class_Control_property_theme>`
.. rst-class:: classref-property-setget
- |void| **set_theme**\ (\ value\: :ref:`Theme<class_Theme>`\ )
- :ref:`Theme<class_Theme>` **get_theme**\ (\ )
Ресурс :ref:`Theme<class_Theme>`, который использует этот узел и все его дочерние элементы **Control** и :ref:`Window<class_Window>`. Если дочерний узел имеет свой собственный набор ресурсов :ref:`Theme<class_Theme>`, элементы темы объединяются с определениями дочернего элемента, имеющими более высокий приоритет.
\ **Примечание:** Стили :ref:`Window<class_Window>` не будут иметь никакого эффекта, если окно не встроено.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_theme_type_variation:
.. rst-class:: classref-property
:ref:`StringName<class_StringName>` **theme_type_variation** = ``&""`` :ref:`🔗<class_Control_property_theme_type_variation>`
.. rst-class:: classref-property-setget
- |void| **set_theme_type_variation**\ (\ value\: :ref:`StringName<class_StringName>`\ )
- :ref:`StringName<class_StringName>` **get_theme_type_variation**\ (\ )
Имя вариации типа темы, используемой этим **Control** для поиска собственных элементов темы. Если пусто, используется имя класса узла (например, ``Button`` для элемента управления :ref:`Button<class_Button>`), а также имена классов всех родительских классов (в порядке наследования).
Если установлено, это свойство дает наивысший приоритет типу указанного имени. Этот тип, в свою очередь, может расширять другой тип, образуя цепочку зависимостей. См. :ref:`Theme.set_type_variation()<class_Theme_method_set_type_variation>`. Если элемент темы не может быть найден с помощью этого типа или его базовых типов, поиск возвращается к именам классов.
\ **Примечание:** Для поиска собственных элементов **Control** используйте различные методы ``get_theme_*`` без указания ``theme_type``.
\ **Примечание:** Элементы темы ищутся в порядке дерева, от ветви к корню, где каждый узел **Control** проверяется на предмет его свойства :ref:`theme<class_Control_property_theme>`. Возвращается самое раннее совпадение с любым именем типа/класса. Тема уровня проекта и тема по умолчанию проверяются последними.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_tooltip_auto_translate_mode:
.. rst-class:: classref-property
:ref:`AutoTranslateMode<enum_Node_AutoTranslateMode>` **tooltip_auto_translate_mode** = ``0`` :ref:`🔗<class_Control_property_tooltip_auto_translate_mode>`
.. rst-class:: classref-property-setget
- |void| **set_tooltip_auto_translate_mode**\ (\ value\: :ref:`AutoTranslateMode<enum_Node_AutoTranslateMode>`\ )
- :ref:`AutoTranslateMode<enum_Node_AutoTranslateMode>` **get_tooltip_auto_translate_mode**\ (\ )
Определяет, должен ли текст подсказки автоматически меняться на переведенную версию в зависимости от текущей локали. Использует тот же режим автоматического перевода, что и этот элемент управления, если задано значение :ref:`Node.AUTO_TRANSLATE_MODE_INHERIT<class_Node_constant_AUTO_TRANSLATE_MODE_INHERIT>`.
\ **Примечание:** Подсказки, настроенные с помощью :ref:`_make_custom_tooltip()<class_Control_private_method__make_custom_tooltip>`, не используют этот режим автоматического перевода автоматически.
.. rst-class:: classref-item-separator
----
.. _class_Control_property_tooltip_text:
.. rst-class:: classref-property
:ref:`String<class_String>` **tooltip_text** = ``""`` :ref:`🔗<class_Control_property_tooltip_text>`
.. rst-class:: classref-property-setget
- |void| **set_tooltip_text**\ (\ value\: :ref:`String<class_String>`\ )
- :ref:`String<class_String>` **get_tooltip_text**\ (\ )
Текст подсказки по умолчанию. Подсказка появляется, когда курсор мыши пользователя остается неподвижным над этим элементом управления в течение нескольких секунд, при условии, что свойство :ref:`mouse_filter<class_Control_property_mouse_filter>` не равно :ref:`MOUSE_FILTER_IGNORE<class_Control_constant_MOUSE_FILTER_IGNORE>`. Время, необходимое для появления подсказки, можно изменить с помощью настройки :ref:`ProjectSettings.gui/timers/tooltip_delay_sec<class_ProjectSettings_property_gui/timers/tooltip_delay_sec>`.
Эта строка является возвращаемым значением по умолчанию для :ref:`get_tooltip()<class_Control_method_get_tooltip>`. Переопределите :ref:`_get_tooltip()<class_Control_private_method__get_tooltip>` для динамической генерации текста подсказки. Переопределите :ref:`_make_custom_tooltip()<class_Control_private_method__make_custom_tooltip>` для настройки пользовательского интерфейса и поведения подсказки.
Всплывающее окно подсказки будет использовать либо реализацию по умолчанию, либо пользовательскую, которую вы можете предоставить, переопределив :ref:`_make_custom_tooltip()<class_Control_private_method__make_custom_tooltip>`. Подсказка по умолчанию включает :ref:`PopupPanel<class_PopupPanel>` и :ref:`Label<class_Label>`, свойства темы которых можно настроить с помощью методов :ref:`Theme<class_Theme>` с ``"TooltipPanel"`` и ``"TooltipLabel"`` соответственно. Например:
.. tabs::
.. code-tab:: gdscript
var style_box = StyleBoxFlat.new()
style_box.set_bg_color(Color(1, 1, 0))
style_box.set_border_width_all(2)
# Здесь мы предполагаем, что свойству `Theme` заранее назначена пользовательская тема.
theme.set_stylebox("panel", "TooltipPanel", style_box)
theme.set_color("font_color", "TooltipLabel", Color(0, 1, 1))
.. code-tab:: csharp
var styleBox = new StyleBoxFlat();
styleBox.SetBgColor(new Color(1, 1, 0));
styleBox.SetBorderWidthAll(2);
// Здесь мы предполагаем, что свойству `Theme` заранее назначена пользовательская тема.
Theme.SetStyleBox("panel", "TooltipPanel", styleBox);
Theme.SetColor("font_color", "TooltipLabel", new Color(0, 1, 1));
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описания метода
------------------------------
.. _class_Control_private_method__accessibility_get_contextual_info:
.. rst-class:: classref-method
:ref:`String<class_String>` **_accessibility_get_contextual_info**\ (\ ) |virtual| |const| :ref:`🔗<class_Control_private_method__accessibility_get_contextual_info>`
Возвращает описание сочетаний клавиш и другую контекстную справку для этого элемента управления.
.. rst-class:: classref-item-separator
----
.. _class_Control_private_method__can_drop_data:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **_can_drop_data**\ (\ at_position\: :ref:`Vector2<class_Vector2>`, data\: :ref:`Variant<class_Variant>`\ ) |virtual| |const| :ref:`🔗<class_Control_private_method__can_drop_data>`
Godot вызывает этот метод, чтобы проверить, можно ли перетащить ``data`` из метода :ref:`_get_drag_data()<class_Control_private_method__get_drag_data>` элемента управления в ``at_position``. ``at_position`` является локальным для этого элемента управления.
Этот метод следует использовать только для проверки данных. Обрабатывайте данные в :ref:`_drop_data()<class_Control_private_method__drop_data>`.
\ **Примечание:** Если перетаскивание было инициировано сочетанием клавиш или :ref:`accessibility_drag()<class_Control_method_accessibility_drag>`, ``at_position`` устанавливается равным :ref:`Vector2.INF<class_Vector2_constant_INF>`, а текущая позиция выбранного элемента/текста должна использоваться в качестве позиции перетаскивания.
.. tabs::
.. code-tab:: gdscript
func _can_drop_data(position, data):
# Проверьте позицию, если она имеет к вам отношение.
# В противном случае просто проверьте данные.
return typeof(data) == TYPE_DICTIONARY and data.has("expected")
.. code-tab:: csharp
public override bool _CanDropData(Vector2 atPosition, Variant data)
{
// Проверьте позицию, если она имеет к вам отношение.
// В противном случае просто проверьте данные.
return data.VariantType == Variant.Type.Dictionary && data.AsGodotDictionary().ContainsKey("expected");
}
.. rst-class:: classref-item-separator
----
.. _class_Control_private_method__drop_data:
.. rst-class:: classref-method
|void| **_drop_data**\ (\ at_position\: :ref:`Vector2<class_Vector2>`, data\: :ref:`Variant<class_Variant>`\ ) |virtual| :ref:`🔗<class_Control_private_method__drop_data>`
Godot вызывает этот метод, чтобы передать вам ``data`` из результата метода :ref:`_get_drag_data()<class_Control_private_method__get_drag_data>` элемента управления. Godot сначала вызывает :ref:`_can_drop_data()<class_Control_private_method__can_drop_data>`, чтобы проверить, разрешено ли перетаскивать ``data`` в ``at_position``, где ``at_position`` является локальным для данного элемента управления.
\ **Примечание:** Если перетаскивание было инициировано сочетанием клавиш или :ref:`accessibility_drag()<class_Control_method_accessibility_drag>`, ``at_position`` устанавливается равным :ref:`Vector2.INF<class_Vector2_constant_INF>`, а текущая позиция выбранного элемента/текста должна использоваться в качестве позиции перетаскивания.
.. tabs::
.. code-tab:: gdscript
func _can_drop_data(position, data):
return typeof(data) == TYPE_DICTIONARY and data.has("color")
func _drop_data(position, data):
var color = data["color"]
.. code-tab:: csharp
public override bool _CanDropData(Vector2 atPosition, Variant data)
{
return data.VariantType == Variant.Type.Dictionary && data.AsGodotDictionary().ContainsKey("color");
}
public override void _DropData(Vector2 atPosition, Variant data)
{
Color color = data.AsGodotDictionary()["color"].AsColor();
}
.. rst-class:: classref-item-separator
----
.. _class_Control_private_method__get_accessibility_container_name:
.. rst-class:: classref-method
:ref:`String<class_String>` **_get_accessibility_container_name**\ (\ node\: :ref:`Node<class_Node>`\ ) |virtual| |const| :ref:`🔗<class_Control_private_method__get_accessibility_container_name>`
Переопределите этот метод, чтобы вернуть понятное для человека описание положения дочернего элемента ``node`` в пользовательском контейнере, добавленном к :ref:`accessibility_name<class_Control_property_accessibility_name>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_private_method__get_drag_data:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **_get_drag_data**\ (\ at_position\: :ref:`Vector2<class_Vector2>`\ ) |virtual| :ref:`🔗<class_Control_private_method__get_drag_data>`
Godot вызывает этот метод для получения данных, которые можно перетаскивать на элементы управления, ожидающие перетаскивания. Возвращает ``null``, если данных для перетаскивания нет. Элементы управления, которые хотят получать перетаскиваемые данные, должны реализовывать :ref:`_can_drop_data()<class_Control_private_method__can_drop_data>` и :ref:`_drop_data()<class_Control_private_method__drop_data>`. ``at_position`` является локальным для этого элемента управления. Перетаскивание может быть принудительно выполнено с помощью :ref:`force_drag()<class_Control_method_force_drag>`.
Предварительный просмотр, который будет следовать за указателем мыши и должен отображать данные, можно установить с помощью :ref:`set_drag_preview()<class_Control_method_set_drag_preview>`. Рекомендуется установить предварительный просмотр в этом методе.
\ **Примечание:** Если перетаскивание было инициировано сочетанием клавиш или :ref:`accessibility_drag()<class_Control_method_accessibility_drag>`, ``at_position`` устанавливается равным :ref:`Vector2.INF<class_Vector2_constant_INF>`, а текущее положение выбранного элемента/текста должно использоваться в качестве позиции перетаскивания.
.. tabs::
.. code-tab:: gdscript
func _get_drag_data(position):
var mydata = make_data() # Это ваш пользовательский метод генерации данных перетаскивания.
set_drag_preview(make_preview(mydata)) # Это ваш пользовательский метод, генерирующий предварительный просмотр данных перетаскивания.
return mydata
.. code-tab:: csharp
public override Variant _GetDragData(Vector2 atPosition)
{
var myData = MakeData(); // Это ваш пользовательский метод генерации данных перетаскивания.
SetDragPreview(MakePreview(myData)); // Это ваш пользовательский метод, генерирующий предварительный просмотр данных перетаскивания.
return myData;
}
.. rst-class:: classref-item-separator
----
.. _class_Control_private_method__get_minimum_size:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **_get_minimum_size**\ (\ ) |virtual| |const| :ref:`🔗<class_Control_private_method__get_minimum_size>`
Виртуальный метод, реализуемый пользователем. Возвращает минимальный размер для этого элемента управления. Альтернатива :ref:`custom_minimum_size<class_Control_property_custom_minimum_size>` для управления минимальным размером через код. Фактический минимальный размер будет максимальным значением этих двух (по каждой оси отдельно).
Если не переопределено, по умолчанию :ref:`Vector2.ZERO<class_Vector2_constant_ZERO>`.
\ **Примечание:** Этот метод не будет вызван, если скрипт прикреплен к узлу **Control**, который уже переопределяет его минимальный размер (например, :ref:`Label<class_Label>`, :ref:`Button<class_Button>`, :ref:`PanelContainer<class_PanelContainer>` и т. д.). Его можно использовать только с большинством базовых узлов GUI, таких как **Control**, :ref:`Container<class_Container>`, :ref:`Panel<class_Panel>` и т. д.
.. rst-class:: classref-item-separator
----
.. _class_Control_private_method__get_tooltip:
.. rst-class:: classref-method
:ref:`String<class_String>` **_get_tooltip**\ (\ at_position\: :ref:`Vector2<class_Vector2>`\ ) |virtual| |const| :ref:`🔗<class_Control_private_method__get_tooltip>`
Виртуальный метод, реализуемый пользователем. Возвращает текст подсказки для позиции ``at_position`` в локальных координатах элемента управления, который обычно отображается, когда курсор находится над этим элементом управления. См. :ref:`get_tooltip()<class_Control_method_get_tooltip>`.
\ **Примечание:** Если этот метод возвращает пустую :ref:`String<class_String>` и :ref:`_make_custom_tooltip()<class_Control_private_method__make_custom_tooltip>` не переопределен, подсказка не отображается.
.. rst-class:: classref-item-separator
----
.. _class_Control_private_method__gui_input:
.. rst-class:: classref-method
|void| **_gui_input**\ (\ event\: :ref:`InputEvent<class_InputEvent>`\ ) |virtual| :ref:`🔗<class_Control_private_method__gui_input>`
Виртуальный метод, реализуемый пользователем. Переопределите этот метод для обработки и принятия ввода в элементах пользовательского интерфейса. См. также :ref:`accept_event()<class_Control_method_accept_event>`.
\ **Пример:** Щелкните элемент управления, чтобы напечатать сообщение:
.. tabs::
.. code-tab:: gdscript
func _gui_input(event):
if event is InputEventMouseButton:
if event.button_index == MOUSE_BUTTON_LEFT and event.pressed:
print("I've been clicked D:")
.. code-tab:: csharp
public override void _GuiInput(InputEvent @event)
{
if (@event is InputEventMouseButton mb)
{
if (mb.ButtonIndex == MouseButton.Left && mb.Pressed)
{
GD.Print("I've been clicked D:");
}
}
}
Если ``event`` наследует :ref:`InputEventMouse<class_InputEventMouse>`, этот метод **не** будет вызван, когда:
- элемент управления :ref:`mouse_filter<class_Control_property_mouse_filter>` установлен на :ref:`MOUSE_FILTER_IGNORE<class_Control_constant_MOUSE_FILTER_IGNORE>`;
- элемент управления перекрыт другим элементом управления сверху, у которого :ref:`mouse_filter<class_Control_property_mouse_filter>` не установлен на :ref:`MOUSE_FILTER_IGNORE<class_Control_constant_MOUSE_FILTER_IGNORE>`;
- родительский элемент управления имеет :ref:`mouse_filter<class_Control_property_mouse_filter>` установлен на :ref:`MOUSE_FILTER_STOP<class_Control_constant_MOUSE_FILTER_STOP>` или принял событие;
- родительский элемент управления имеет :ref:`clip_contents<class_Control_property_clip_contents>`, а положение ``event`` находится вне прямоугольника родителя;
- положение ``event`` находится вне элемента управления (см. :ref:`_has_point()<class_Control_private_method__has_point>`).
\ **Примечание:** Положение ``event`` определяется относительно начала координат этого элемента управления.
.. rst-class:: classref-item-separator
----
.. _class_Control_private_method__has_point:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **_has_point**\ (\ point\: :ref:`Vector2<class_Vector2>`\ ) |virtual| |const| :ref:`🔗<class_Control_private_method__has_point>`
Виртуальный метод, реализуемый пользователем. Возвращает, находится ли заданный ``point`` внутри этого элемента управления.
Если не переопределено, поведение по умолчанию — проверка того, находится ли точка внутри Rect элемента управления.
\ **Примечание:** Если вы хотите проверить, находится ли точка внутри элемента управления, вы можете использовать ``Rect2(Vector2.ZERO, size).has_point(point)``.
.. rst-class:: classref-item-separator
----
.. _class_Control_private_method__make_custom_tooltip:
.. rst-class:: classref-method
:ref:`Object<class_Object>` **_make_custom_tooltip**\ (\ for_text\: :ref:`String<class_String>`\ ) |virtual| |const| :ref:`🔗<class_Control_private_method__make_custom_tooltip>`
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 :ref:`get_tooltip()<class_Control_method_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 :ref:`PopupPanel<class_PopupPanel>`, so you should only provide the contents of that panel. That :ref:`PopupPanel<class_PopupPanel>` can be themed using :ref:`Theme.set_stylebox()<class_Theme_method_set_stylebox>` for the type ``"TooltipPanel"`` (see :ref:`tooltip_text<class_Control_property_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 :ref:`custom_minimum_size<class_Control_property_custom_minimum_size>` to some non-zero value.
\ **Note:** The node (and any relevant children) should have their :ref:`CanvasItem.visible<class_CanvasItem_property_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 :ref:`get_tooltip()<class_Control_method_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:
.. tabs::
.. code-tab:: gdscript
func _make_custom_tooltip(for_text):
var label = Label.new()
label.text = for_text
return label
.. code-tab:: csharp
public override Control _MakeCustomTooltip(string forText)
{
var label = new Label();
label.Text = forText;
return label;
}
\ **Example:** Use a scene instance as a tooltip:
.. tabs::
.. code-tab:: gdscript
func _make_custom_tooltip(for_text):
var tooltip = preload("res://some_tooltip_scene.tscn").instantiate()
tooltip.get_node("Label").text = for_text
return tooltip
.. code-tab:: csharp
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;
}
.. rst-class:: classref-item-separator
----
.. _class_Control_private_method__structured_text_parser:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`Vector3i<class_Vector3i>`\] **_structured_text_parser**\ (\ args\: :ref:`Array<class_Array>`, text\: :ref:`String<class_String>`\ ) |virtual| |const| :ref:`🔗<class_Control_private_method__structured_text_parser>`
Функция переопределения пользовательского алгоритма BiDi.
Возвращает :ref:`Array<class_Array>` из :ref:`Vector3i<class_Vector3i>` текстовых диапазонов и направлений баз текста в порядке слева направо. Диапазоны должны охватывать весь исходный ``text`` без перекрытий. Алгоритм BiDi будет использоваться для каждого диапазона отдельно.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_accept_event:
.. rst-class:: classref-method
|void| **accept_event**\ (\ ) :ref:`🔗<class_Control_method_accept_event>`
Отмечает событие ввода как обработанное. После того, как вы принимаете событие ввода, оно перестает распространяться, даже на узлы, прослушивающие :ref:`Node._unhandled_input()<class_Node_private_method__unhandled_input>` или :ref:`Node._unhandled_key_input()<class_Node_private_method__unhandled_key_input>`.
\ **Примечание:** Это не влияет на методы в :ref:`Input<class_Input>`, а только на способ распространения событий.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_accessibility_drag:
.. rst-class:: classref-method
|void| **accessibility_drag**\ (\ ) :ref:`🔗<class_Control_method_accessibility_drag>`
Запускает операцию перетаскивания без использования мыши.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_accessibility_drop:
.. rst-class:: classref-method
|void| **accessibility_drop**\ (\ ) :ref:`🔗<class_Control_method_accessibility_drop>`
Завершает операцию перетаскивания без использования мыши.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_add_theme_color_override:
.. rst-class:: classref-method
|void| **add_theme_color_override**\ (\ name\: :ref:`StringName<class_StringName>`, color\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_Control_method_add_theme_color_override>`
Создает локальное переопределение для темы :ref:`Color<class_Color>` с указанным ``name``. Локальные переопределения всегда имеют приоритет при извлечении элементов темы для элемента управления. Переопределение можно удалить с помощью :ref:`remove_theme_color_override()<class_Control_method_remove_theme_color_override>`.
С. также :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
\ **Пример:** Переопределить цвет :ref:`Label<class_Label>` и сбросить его позже:
.. tabs::
.. code-tab:: gdscript
# Для дочернего узла Label «MyLabel» переопределите цвет его шрифта с помощью пользовательского значения.
$MyLabel.add_theme_color_override("font_color", Color(1, 0.5, 0))
# Сбросить цвет шрифта дочерней метки.
$MyLabel.remove_theme_color_override("font_color")
# В качестве альтернативы его можно переопределить значением по умолчанию из типа метки.
$MyLabel.add_theme_color_override("font_color", get_theme_color("font_color", "Label"))
.. code-tab:: csharp
// Для дочернего узла Label «MyLabel» переопределите цвет его шрифта с помощью пользовательского значения.
GetNode<Label>("MyLabel").AddThemeColorOverride("font_color", new Color(1, 0.5f, 0));
// Сбросить цвет шрифта дочерней метки.
GetNode<Label>("MyLabel").RemoveThemeColorOverride("font_color");
// В качестве альтернативы его можно переопределить значением по умолчанию из типа метки.
GetNode<Label>("MyLabel").AddThemeColorOverride("font_color", GetThemeColor("font_color", "Label"));
.. rst-class:: classref-item-separator
----
.. _class_Control_method_add_theme_constant_override:
.. rst-class:: classref-method
|void| **add_theme_constant_override**\ (\ name\: :ref:`StringName<class_StringName>`, constant\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Control_method_add_theme_constant_override>`
Создает локальное переопределение для константы темы с указанным ``name``. Локальные переопределения всегда имеют приоритет при извлечении элементов темы для элемента управления. Переопределение можно удалить с помощью :ref:`remove_theme_constant_override()<class_Control_method_remove_theme_constant_override>`.
См. также :ref:`get_theme_constant()<class_Control_method_get_theme_constant>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_add_theme_font_override:
.. rst-class:: classref-method
|void| **add_theme_font_override**\ (\ name\: :ref:`StringName<class_StringName>`, font\: :ref:`Font<class_Font>`\ ) :ref:`🔗<class_Control_method_add_theme_font_override>`
Создает локальное переопределение для темы :ref:`Font<class_Font>` с указанным ``name``. Локальные переопределения всегда имеют приоритет при извлечении элементов темы для элемента управления. Переопределение можно удалить с помощью :ref:`remove_theme_font_override()<class_Control_method_remove_theme_font_override>`.
См. также :ref:`get_theme_font()<class_Control_method_get_theme_font>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_add_theme_font_size_override:
.. rst-class:: classref-method
|void| **add_theme_font_size_override**\ (\ name\: :ref:`StringName<class_StringName>`, font_size\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Control_method_add_theme_font_size_override>`
Создает локальное переопределение для размера шрифта темы с указанным ``name``. Локальные переопределения всегда имеют приоритет при извлечении элементов темы для элемента управления. Переопределение можно удалить с помощью :ref:`remove_theme_font_size_override()<class_Control_method_remove_theme_font_size_override>`.
См. также :ref:`get_theme_font_size()<class_Control_method_get_theme_font_size>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_add_theme_icon_override:
.. rst-class:: classref-method
|void| **add_theme_icon_override**\ (\ name\: :ref:`StringName<class_StringName>`, texture\: :ref:`Texture2D<class_Texture2D>`\ ) :ref:`🔗<class_Control_method_add_theme_icon_override>`
Создает локальное переопределение для значка темы с указанным ``name``. Локальные переопределения всегда имеют приоритет при извлечении элементов темы для элемента управления. Переопределение можно удалить с помощью :ref:`remove_theme_icon_override()<class_Control_method_remove_theme_icon_override>`.
См. также :ref:`get_theme_icon()<class_Control_method_get_theme_icon>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_add_theme_stylebox_override:
.. rst-class:: classref-method
|void| **add_theme_stylebox_override**\ (\ name\: :ref:`StringName<class_StringName>`, stylebox\: :ref:`StyleBox<class_StyleBox>`\ ) :ref:`🔗<class_Control_method_add_theme_stylebox_override>`
Создает локальное переопределение для темы :ref:`StyleBox<class_StyleBox>` с указанным ``name``. Локальные переопределения всегда имеют приоритет при извлечении элементов темы для элемента управления. Переопределение можно удалить с помощью :ref:`remove_theme_stylebox_override()<class_Control_method_remove_theme_stylebox_override>`.
См. также :ref:`get_theme_stylebox()<class_Control_method_get_theme_stylebox>`.
\ **Пример:** Измените свойство в :ref:`StyleBox<class_StyleBox>`, продублировав его:
.. tabs::
.. code-tab:: gdscript
# В приведенном ниже фрагменте предполагается, что дочернему узлу «MyButton» назначен StyleBoxFlat.
# Ресурсы являются общими для всех экземпляров, поэтому нам нужно их дублировать.
# чтобы избежать изменения внешнего вида всех остальных кнопок.
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)
# Удалить переопределение stylebox.
$MyButton.remove_theme_stylebox_override("normal")
.. code-tab:: csharp
// В приведенном ниже фрагменте предполагается, что дочернему узлу «MyButton» назначен StyleBoxFlat.
// Ресурсы являются общими для всех экземпляров, поэтому нам нужно их дублировать.
// чтобы избежать изменения внешнего вида всех остальных кнопок.
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);
// Удалить переопределение stylebox.
GetNode<Button>("MyButton").RemoveThemeStyleboxOverride("normal");
.. rst-class:: classref-item-separator
----
.. _class_Control_method_begin_bulk_theme_override:
.. rst-class:: classref-method
|void| **begin_bulk_theme_override**\ (\ ) :ref:`🔗<class_Control_method_begin_bulk_theme_override>`
Запрещает методам ``*_theme_*_override`` выдавать :ref:`NOTIFICATION_THEME_CHANGED<class_Control_constant_NOTIFICATION_THEME_CHANGED>` до тех пор, пока не будет вызван :ref:`end_bulk_theme_override()<class_Control_method_end_bulk_theme_override>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_end_bulk_theme_override:
.. rst-class:: classref-method
|void| **end_bulk_theme_override**\ (\ ) :ref:`🔗<class_Control_method_end_bulk_theme_override>`
Завершает массовое обновление переопределения темы. См. :ref:`begin_bulk_theme_override()<class_Control_method_begin_bulk_theme_override>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_find_next_valid_focus:
.. rst-class:: classref-method
:ref:`Control<class_Control>` **find_next_valid_focus**\ (\ ) |const| :ref:`🔗<class_Control_method_find_next_valid_focus>`
Находит следующий (ниже в дереве) **Control**, который может получить фокус.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_find_prev_valid_focus:
.. rst-class:: classref-method
:ref:`Control<class_Control>` **find_prev_valid_focus**\ (\ ) |const| :ref:`🔗<class_Control_method_find_prev_valid_focus>`
Находит предыдущий (выше в дереве) **Control**, который может получить фокус.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_find_valid_focus_neighbor:
.. rst-class:: classref-method
:ref:`Control<class_Control>` **find_valid_focus_neighbor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const| :ref:`🔗<class_Control_method_find_valid_focus_neighbor>`
Находит следующий **Control**, который может получить фокус на указанной :ref:`Side<enum_@GlobalScope_Side>`.
\ **Примечание:** Это отличается от :ref:`get_focus_neighbor()<class_Control_method_get_focus_neighbor>`, который возвращает путь указанного соседа фокуса.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_force_drag:
.. rst-class:: classref-method
|void| **force_drag**\ (\ data\: :ref:`Variant<class_Variant>`, preview\: :ref:`Control<class_Control>`\ ) :ref:`🔗<class_Control_method_force_drag>`
Принудительно перетаскивает и обходит :ref:`_get_drag_data()<class_Control_private_method__get_drag_data>` и :ref:`set_drag_preview()<class_Control_method_set_drag_preview>`, передавая ``data`` и ``preview``. Перетаскивание начнется, даже если мышь не находится над этим элементом управления и не нажата на него.
Методы :ref:`_can_drop_data()<class_Control_private_method__can_drop_data>` и :ref:`_drop_data()<class_Control_private_method__drop_data>` должны быть реализованы в элементах управления, которые хотят получать данные перетаскивания.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_anchor:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_anchor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const| :ref:`🔗<class_Control_method_get_anchor>`
Возвращает якорь для указанного :ref:`Side<enum_@GlobalScope_Side>`. Метод получения для :ref:`anchor_bottom<class_Control_property_anchor_bottom>`, :ref:`anchor_left<class_Control_property_anchor_left>`, :ref:`anchor_right<class_Control_property_anchor_right>` и :ref:`anchor_top<class_Control_property_anchor_top>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_begin:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_begin**\ (\ ) |const| :ref:`🔗<class_Control_method_get_begin>`
Возвращает :ref:`offset_left<class_Control_property_offset_left>` и :ref:`offset_top<class_Control_property_offset_top>`. См. также :ref:`position<class_Control_property_position>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_combined_minimum_size:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_combined_minimum_size**\ (\ ) |const| :ref:`🔗<class_Control_method_get_combined_minimum_size>`
Возвращает объединенный минимальный размер из :ref:`custom_minimum_size<class_Control_property_custom_minimum_size>` и :ref:`get_minimum_size()<class_Control_method_get_minimum_size>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_combined_pivot_offset:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_combined_pivot_offset**\ (\ ) |const| :ref:`🔗<class_Control_method_get_combined_pivot_offset>`
Returns the combined value of :ref:`pivot_offset<class_Control_property_pivot_offset>` and :ref:`pivot_offset_ratio<class_Control_property_pivot_offset_ratio>`, in pixels. The ratio is multiplied by the control's size.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_cursor_shape:
.. rst-class:: classref-method
:ref:`CursorShape<enum_Control_CursorShape>` **get_cursor_shape**\ (\ position\: :ref:`Vector2<class_Vector2>` = Vector2(0, 0)\ ) |const| :ref:`🔗<class_Control_method_get_cursor_shape>`
Возвращает форму курсора мыши для этого элемента управления при наведении на ``position`` в локальных координатах. Для большинства элементов управления это то же самое, что и :ref:`mouse_default_cursor_shape<class_Control_property_mouse_default_cursor_shape>`, но некоторые встроенные элементы управления реализуют более сложную логику.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_end:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_end**\ (\ ) |const| :ref:`🔗<class_Control_method_get_end>`
Возвращает :ref:`offset_right<class_Control_property_offset_right>` и :ref:`offset_bottom<class_Control_property_offset_bottom>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_focus_mode_with_override:
.. rst-class:: classref-method
:ref:`FocusMode<enum_Control_FocusMode>` **get_focus_mode_with_override**\ (\ ) |const| :ref:`🔗<class_Control_method_get_focus_mode_with_override>`
Возвращает :ref:`focus_mode<class_Control_property_focus_mode>`, но учитывает :ref:`focus_behavior_recursive<class_Control_property_focus_behavior_recursive>`. Если :ref:`focus_behavior_recursive<class_Control_property_focus_behavior_recursive>` установлен на :ref:`FOCUS_BEHAVIOR_DISABLED<class_Control_constant_FOCUS_BEHAVIOR_DISABLED>` или установлен на :ref:`FOCUS_BEHAVIOR_INHERITED<class_Control_constant_FOCUS_BEHAVIOR_INHERITED>`, а его предок установлен на :ref:`FOCUS_BEHAVIOR_DISABLED<class_Control_constant_FOCUS_BEHAVIOR_DISABLED>`, то возвращается :ref:`FOCUS_NONE<class_Control_constant_FOCUS_NONE>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_focus_neighbor:
.. rst-class:: classref-method
:ref:`NodePath<class_NodePath>` **get_focus_neighbor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const| :ref:`🔗<class_Control_method_get_focus_neighbor>`
Возвращает соседа фокуса для указанного :ref:`Side<enum_@GlobalScope_Side>`. Метод получения для :ref:`focus_neighbor_bottom<class_Control_property_focus_neighbor_bottom>`, :ref:`focus_neighbor_left<class_Control_property_focus_neighbor_left>`, :ref:`focus_neighbor_right<class_Control_property_focus_neighbor_right>` и :ref:`focus_neighbor_top<class_Control_property_focus_neighbor_top>`.
\ **Примечание:** Чтобы найти следующий **Control** на указанном :ref:`Side<enum_@GlobalScope_Side>`, даже если сосед не назначен, используйте :ref:`find_valid_focus_neighbor()<class_Control_method_find_valid_focus_neighbor>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_global_rect:
.. rst-class:: classref-method
:ref:`Rect2<class_Rect2>` **get_global_rect**\ (\ ) |const| :ref:`🔗<class_Control_method_get_global_rect>`
Возвращает положение и размер элемента управления относительно содержащего его холста. См. :ref:`global_position<class_Control_property_global_position>` и :ref:`size<class_Control_property_size>`.
\ **Примечание:** Если сам узел или любой родительский :ref:`CanvasItem<class_CanvasItem>` между узлом и холстом имеет нестандартный поворот или наклон, то результирующий размер, скорее всего, не имеет смысла.
\ **Примечание:** Установка :ref:`Viewport.gui_snap_controls_to_pixels<class_Viewport_property_gui_snap_controls_to_pixels>` в ``true`` может привести к неточностям округления между отображаемым элементом управления и возвращаемым :ref:`Rect2<class_Rect2>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_minimum_size:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_minimum_size**\ (\ ) |const| :ref:`🔗<class_Control_method_get_minimum_size>`
Возвращает минимальный размер для этого элемента управления. См. :ref:`custom_minimum_size<class_Control_property_custom_minimum_size>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_mouse_filter_with_override:
.. rst-class:: classref-method
:ref:`MouseFilter<enum_Control_MouseFilter>` **get_mouse_filter_with_override**\ (\ ) |const| :ref:`🔗<class_Control_method_get_mouse_filter_with_override>`
Возвращает :ref:`mouse_filter<class_Control_property_mouse_filter>`, но учитывает :ref:`mouse_behavior_recursive<class_Control_property_mouse_behavior_recursive>`. Если :ref:`mouse_behavior_recursive<class_Control_property_mouse_behavior_recursive>` установлен на :ref:`MOUSE_BEHAVIOR_DISABLED<class_Control_constant_MOUSE_BEHAVIOR_DISABLED>` или установлен на :ref:`MOUSE_BEHAVIOR_INHERITED<class_Control_constant_MOUSE_BEHAVIOR_INHERITED>`, а его предок установлен на :ref:`MOUSE_BEHAVIOR_DISABLED<class_Control_constant_MOUSE_BEHAVIOR_DISABLED>`, то возвращается :ref:`MOUSE_FILTER_IGNORE<class_Control_constant_MOUSE_FILTER_IGNORE>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_offset:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_offset**\ (\ offset\: :ref:`Side<enum_@GlobalScope_Side>`\ ) |const| :ref:`🔗<class_Control_method_get_offset>`
Возвращает смещение для указанного :ref:`Side<enum_@GlobalScope_Side>`. Метод получения для :ref:`offset_bottom<class_Control_property_offset_bottom>`, :ref:`offset_left<class_Control_property_offset_left>`, :ref:`offset_right<class_Control_property_offset_right>` и :ref:`offset_top<class_Control_property_offset_top>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_parent_area_size:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_parent_area_size**\ (\ ) |const| :ref:`🔗<class_Control_method_get_parent_area_size>`
Возвращает ширину/высоту, занимаемую родительским элементом управления.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_parent_control:
.. rst-class:: classref-method
:ref:`Control<class_Control>` **get_parent_control**\ (\ ) |const| :ref:`🔗<class_Control_method_get_parent_control>`
Возвращает родительский управляющий узел.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_rect:
.. rst-class:: classref-method
:ref:`Rect2<class_Rect2>` **get_rect**\ (\ ) |const| :ref:`🔗<class_Control_method_get_rect>`
Возвращает положение и размер элемента управления в системе координат содержащего узла. См. :ref:`position<class_Control_property_position>`, :ref:`scale<class_Control_property_scale>` и :ref:`size<class_Control_property_size>`.
\ **Примечание:** Если :ref:`rotation<class_Control_property_rotation>` не является поворотом по умолчанию, результирующий размер не имеет смысла.
\ **Примечание:** Установка :ref:`Viewport.gui_snap_controls_to_pixels<class_Viewport_property_gui_snap_controls_to_pixels>` в ``true`` может привести к неточностям округления между отображаемым элементом управления и возвращаемым :ref:`Rect2<class_Rect2>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_screen_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_screen_position**\ (\ ) |const| :ref:`🔗<class_Control_method_get_screen_position>`
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 :ref:`CanvasItem.get_screen_transform()<class_CanvasItem_method_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()
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_theme_color:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **get_theme_color**\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| :ref:`🔗<class_Control_method_get_theme_color>`
Возвращает :ref:`Color<class_Color>` из первой совпадающей :ref:`Theme<class_Theme>` в дереве, если эта :ref:`Theme<class_Theme>` имеет элемент цвета с указанными ``name`` и ``theme_type``. Если ``theme_type`` опущен, в качестве типа используется имя класса текущего элемента управления или :ref:`theme_type_variation<class_Control_property_theme_type_variation>`, если он определен. Если тип является именем класса, его родительские классы также проверяются в порядке наследования. Если тип является вариацией, его базовые типы проверяются в порядке зависимости, затем проверяются имя класса элемента управления и его родительские классы.
Для текущего элемента управления сначала рассматриваются его локальные переопределения (см. :ref:`add_theme_color_override()<class_Control_method_add_theme_color_override>`), затем его назначенная :ref:`theme<class_Control_property_theme>`. После текущего элемента управления рассматриваются каждый родительский элемент управления и назначенная ему :ref:`theme<class_Control_property_theme>`; элементы управления без назначенной :ref:`theme<class_Control_property_theme>` пропускаются. Если в дереве не найдено соответствующей :ref:`Theme<class_Theme>`, используются пользовательский проект :ref:`Theme<class_Theme>` (см. :ref:`ProjectSettings.gui/theme/custom<class_ProjectSettings_property_gui/theme/custom>`) и :ref:`Theme<class_Theme>` по умолчанию (см. :ref:`ThemeDB<class_ThemeDB>`).
.. tabs::
.. code-tab:: gdscript
func _ready():
# Получить цвет шрифта, определенный для текущего класса элемента управления, если он существует.
modulate = get_theme_color("font_color")
# Получите цвет шрифта, определенный для класса Button.
modulate = get_theme_color("font_color", "Button")
.. code-tab:: csharp
public override void _Ready()
{
// Получить цвет шрифта, определенный для текущего класса элемента управления, если он существует.
Modulate = GetThemeColor("font_color");
// Получите цвет шрифта, определенный для класса Button.
Modulate = GetThemeColor("font_color", "Button");
}
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_theme_constant:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_theme_constant**\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| :ref:`🔗<class_Control_method_get_theme_constant>`
Возвращает константу из первой совпадающей :ref:`Theme<class_Theme>` в дереве, если эта :ref:`Theme<class_Theme>` имеет константный элемент с указанными ``name`` и ``theme_type``.
Подробности см. в :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_theme_default_base_scale:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_theme_default_base_scale**\ (\ ) |const| :ref:`🔗<class_Control_method_get_theme_default_base_scale>`
Возвращает базовое значение масштаба по умолчанию из первой соответствующей :ref:`Theme<class_Theme>` в дереве, если эта :ref:`Theme<class_Theme>` имеет допустимое значение :ref:`Theme.default_base_scale<class_Theme_property_default_base_scale>`.
Подробнее см. в :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_theme_default_font:
.. rst-class:: classref-method
:ref:`Font<class_Font>` **get_theme_default_font**\ (\ ) |const| :ref:`🔗<class_Control_method_get_theme_default_font>`
Возвращает шрифт по умолчанию из первой соответствующей :ref:`Theme<class_Theme>` в дереве, если эта :ref:`Theme<class_Theme>` имеет допустимое значение :ref:`Theme.default_font<class_Theme_property_default_font>`.
Подробности см. в :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_theme_default_font_size:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_theme_default_font_size**\ (\ ) |const| :ref:`🔗<class_Control_method_get_theme_default_font_size>`
Возвращает значение размера шрифта по умолчанию из первой соответствующей :ref:`Theme<class_Theme>` в дереве, если эта :ref:`Theme<class_Theme>` имеет допустимое значение :ref:`Theme.default_font_size<class_Theme_property_default_font_size>`.
Подробности см. в :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_theme_font:
.. rst-class:: classref-method
:ref:`Font<class_Font>` **get_theme_font**\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| :ref:`🔗<class_Control_method_get_theme_font>`
Возвращает :ref:`Font<class_Font>` из первой соответствующей :ref:`Theme<class_Theme>` в дереве, если эта :ref:`Theme<class_Theme>` имеет элемент шрифта с указанными ``name`` и ``name``.
Подробности см. в :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_theme_font_size:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_theme_font_size**\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| :ref:`🔗<class_Control_method_get_theme_font_size>`
Возвращает размер шрифта из первой соответствующей :ref:`Theme<class_Theme>` в дереве, если эта :ref:`Theme<class_Theme>` имеет элемент размера шрифта с указанными ``name`` и ``theme_type``.
Подробности см. в :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_theme_icon:
.. rst-class:: classref-method
:ref:`Texture2D<class_Texture2D>` **get_theme_icon**\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| :ref:`🔗<class_Control_method_get_theme_icon>`
Возвращает значок из первой соответствующей :ref:`Theme<class_Theme>` в дереве, если эта :ref:`Theme<class_Theme>` имеет элемент значка с указанными ``name`` и ``theme_type``.
Подробности см. в :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_theme_stylebox:
.. rst-class:: classref-method
:ref:`StyleBox<class_StyleBox>` **get_theme_stylebox**\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| :ref:`🔗<class_Control_method_get_theme_stylebox>`
Возвращает :ref:`StyleBox<class_StyleBox>` из первой соответствующей :ref:`Theme<class_Theme>` в дереве, если эта :ref:`Theme<class_Theme>` имеет элемент stylebox с указанными ``name`` и ``theme_type``.
Подробнее см. :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_get_tooltip:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_tooltip**\ (\ at_position\: :ref:`Vector2<class_Vector2>` = Vector2(0, 0)\ ) |const| :ref:`🔗<class_Control_method_get_tooltip>`
Возвращает текст подсказки для позиции ``at_position`` в локальных координатах элемента управления, который обычно отображается, когда курсор находится над этим элементом управления. По умолчанию он возвращает :ref:`tooltip_text<class_Control_property_tooltip_text>`.
Этот метод можно переопределить, чтобы настроить его поведение. См. :ref:`_get_tooltip()<class_Control_private_method__get_tooltip>`.
\ **Примечание:** Если этот метод возвращает пустую :ref:`String<class_String>` и :ref:`_make_custom_tooltip()<class_Control_private_method__make_custom_tooltip>` не переопределен, подсказка не отображается.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_grab_click_focus:
.. rst-class:: classref-method
|void| **grab_click_focus**\ (\ ) :ref:`🔗<class_Control_method_grab_click_focus>`
Создает :ref:`InputEventMouseButton<class_InputEventMouseButton>`, который пытается щелкнуть элемент управления. Если событие получено, элемент управления получает фокус.
.. tabs::
.. code-tab:: gdscript
func _process(delta):
grab_click_focus() # При щелчке по другому узлу управления вместо него будет выполнен щелчок по этому узлу.
.. code-tab:: csharp
public override void _Process(double delta)
{
GrabClickFocus(); // При щелчке по другому узлу управления вместо него будет выполнен щелчок по этому узлу.
}
.. rst-class:: classref-item-separator
----
.. _class_Control_method_grab_focus:
.. rst-class:: classref-method
|void| **grab_focus**\ (\ hide_focus\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_Control_method_grab_focus>`
Steal the focus from another control and become the focused control (see :ref:`focus_mode<class_Control_property_focus_mode>`).
If ``hide_focus`` is ``true``, the control will not visually show its focused state. Has no effect for :ref:`LineEdit<class_LineEdit>` and :ref:`TextEdit<class_TextEdit>` when :ref:`ProjectSettings.gui/common/show_focus_state_on_pointer_event<class_ProjectSettings_property_gui/common/show_focus_state_on_pointer_event>` is set to ``Control Supports Keyboard Input``, or for any control when it is set to ``Always``.
\ **Note:** Using this method together with :ref:`Callable.call_deferred()<class_Callable_method_call_deferred>` makes it more reliable, especially when called inside :ref:`Node._ready()<class_Node_private_method__ready>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_has_focus:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_focus**\ (\ ignore_hidden_focus\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Control_method_has_focus>`
Returns ``true`` if this is the current focused control. See :ref:`focus_mode<class_Control_property_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 :ref:`grab_focus()<class_Control_method_grab_focus>` with ``hide_focus`` set to ``true``.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_has_theme_color:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_theme_color**\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| :ref:`🔗<class_Control_method_has_theme_color>`
Возвращает ``true``, если в дереве есть соответствующая :ref:`Theme<class_Theme>`, которая имеет элемент цвета с указанными ``name`` и ``theme_type``.
Подробнее см. :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_has_theme_color_override:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_theme_color_override**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| :ref:`🔗<class_Control_method_has_theme_color_override>`
Возвращает ``true``, если есть локальное переопределение для темы :ref:`Color<class_Color>` с указанным ``name`` в этом узле **Control**.
См. :ref:`add_theme_color_override()<class_Control_method_add_theme_color_override>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_has_theme_constant:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_theme_constant**\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| :ref:`🔗<class_Control_method_has_theme_constant>`
Возвращает ``true``, если в дереве есть соответствующая :ref:`Theme<class_Theme>`, которая имеет постоянный элемент с указанными ``name`` и ``theme_type``.
Подробнее см. :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_has_theme_constant_override:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_theme_constant_override**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| :ref:`🔗<class_Control_method_has_theme_constant_override>`
Возвращает ``true``, если есть локальное переопределение для константы темы с указанным ``name`` в этом узле **Control**.
См. :ref:`add_theme_constant_override()<class_Control_method_add_theme_constant_override>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_has_theme_font:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_theme_font**\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| :ref:`🔗<class_Control_method_has_theme_font>`
Возвращает ``true``, если в дереве есть соответствующая :ref:`Theme<class_Theme>`, которая имеет элемент шрифта с указанными ``name`` и ``theme_type``.
Подробнее см. :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_has_theme_font_override:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_theme_font_override**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| :ref:`🔗<class_Control_method_has_theme_font_override>`
Возвращает ``true``, если есть локальное переопределение для темы :ref:`Font<class_Font>` с указанным ``name`` в этом узле **Control**.
См. :ref:`add_theme_font_override()<class_Control_method_add_theme_font_override>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_has_theme_font_size:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_theme_font_size**\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| :ref:`🔗<class_Control_method_has_theme_font_size>`
Возвращает ``true``, если в дереве есть соответствующая :ref:`Theme<class_Theme>`, которая имеет элемент размера шрифта с указанными ``name`` и ``theme_type``.
Подробности см. в :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_has_theme_font_size_override:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_theme_font_size_override**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| :ref:`🔗<class_Control_method_has_theme_font_size_override>`
Возвращает ``true``, если есть локальное переопределение для размера шрифта темы с указанным ``name`` в этом узле **Control**.
См. :ref:`add_theme_font_size_override()<class_Control_method_add_theme_font_size_override>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_has_theme_icon:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_theme_icon**\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| :ref:`🔗<class_Control_method_has_theme_icon>`
Возвращает ``true``, если в дереве есть соответствующая :ref:`Theme<class_Theme>`, которая имеет элемент значка с указанными ``name`` и ``theme_type``.
Подробнее см. :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_has_theme_icon_override:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_theme_icon_override**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| :ref:`🔗<class_Control_method_has_theme_icon_override>`
Возвращает ``true``, если есть локальное переопределение для значка темы с указанным ``name`` в этом узле **Control**.
См. :ref:`add_theme_icon_override()<class_Control_method_add_theme_icon_override>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_has_theme_stylebox:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_theme_stylebox**\ (\ name\: :ref:`StringName<class_StringName>`, theme_type\: :ref:`StringName<class_StringName>` = &""\ ) |const| :ref:`🔗<class_Control_method_has_theme_stylebox>`
Возвращает ``true``, если в дереве есть соответствующая :ref:`Theme<class_Theme>`, которая имеет элемент stylebox с указанными ``name`` и ``theme_type``.
Подробнее см. :ref:`get_theme_color()<class_Control_method_get_theme_color>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_has_theme_stylebox_override:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_theme_stylebox_override**\ (\ name\: :ref:`StringName<class_StringName>`\ ) |const| :ref:`🔗<class_Control_method_has_theme_stylebox_override>`
Возвращает ``true``, если есть локальное переопределение для темы :ref:`StyleBox<class_StyleBox>` с указанным ``name`` в этом узле **Control**.
См. :ref:`add_theme_stylebox_override()<class_Control_method_add_theme_stylebox_override>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_is_drag_successful:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_drag_successful**\ (\ ) |const| :ref:`🔗<class_Control_method_is_drag_successful>`
Возвращает ``true``, если операция перетаскивания прошла успешно. Альтернатива :ref:`Viewport.gui_is_drag_successful()<class_Viewport_method_gui_is_drag_successful>`.
Лучше всего использовать с :ref:`Node.NOTIFICATION_DRAG_END<class_Node_constant_NOTIFICATION_DRAG_END>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_is_layout_rtl:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_layout_rtl**\ (\ ) |const| :ref:`🔗<class_Control_method_is_layout_rtl>`
Возвращает ``true``, если макет справа налево. См. также :ref:`layout_direction<class_Control_property_layout_direction>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_release_focus:
.. rst-class:: classref-method
|void| **release_focus**\ (\ ) :ref:`🔗<class_Control_method_release_focus>`
Откажитесь от фокуса. Никакой другой элемент управления не сможет получить входные данные.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_remove_theme_color_override:
.. rst-class:: classref-method
|void| **remove_theme_color_override**\ (\ name\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_Control_method_remove_theme_color_override>`
Удаляет локальное переопределение для темы :ref:`Color<class_Color>` с указанным ``name``, ранее добавленное с помощью :ref:`add_theme_color_override()<class_Control_method_add_theme_color_override>` или через панель инспектора.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_remove_theme_constant_override:
.. rst-class:: classref-method
|void| **remove_theme_constant_override**\ (\ name\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_Control_method_remove_theme_constant_override>`
Удаляет локальное переопределение для константы темы с указанным ``name``, ранее добавленное :ref:`add_theme_constant_override()<class_Control_method_add_theme_constant_override>` или через панель инспектора.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_remove_theme_font_override:
.. rst-class:: classref-method
|void| **remove_theme_font_override**\ (\ name\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_Control_method_remove_theme_font_override>`
Удаляет локальное переопределение для темы :ref:`Font<class_Font>` с указанным ``name``, ранее добавленное :ref:`add_theme_font_override()<class_Control_method_add_theme_font_override>` или через панель инспектора.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_remove_theme_font_size_override:
.. rst-class:: classref-method
|void| **remove_theme_font_size_override**\ (\ name\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_Control_method_remove_theme_font_size_override>`
Удаляет локальное переопределение размера шрифта темы с указанным ``name``, ранее добавленное :ref:`add_theme_font_size_override()<class_Control_method_add_theme_font_size_override>` или через панель инспектора.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_remove_theme_icon_override:
.. rst-class:: classref-method
|void| **remove_theme_icon_override**\ (\ name\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_Control_method_remove_theme_icon_override>`
Удаляет локальное переопределение для значка темы с указанным ``name``, ранее добавленное :ref:`add_theme_icon_override()<class_Control_method_add_theme_icon_override>` или через панель инспектора.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_remove_theme_stylebox_override:
.. rst-class:: classref-method
|void| **remove_theme_stylebox_override**\ (\ name\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_Control_method_remove_theme_stylebox_override>`
Удаляет локальное переопределение для темы :ref:`StyleBox<class_StyleBox>` с указанным ``name``, ранее добавленное :ref:`add_theme_stylebox_override()<class_Control_method_add_theme_stylebox_override>` или через панель инспектора.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_reset_size:
.. rst-class:: classref-method
|void| **reset_size**\ (\ ) :ref:`🔗<class_Control_method_reset_size>`
Сбрасывает размер до :ref:`get_combined_minimum_size()<class_Control_method_get_combined_minimum_size>`. Это эквивалентно вызову ``set_size(Vector2())`` (или любого размера ниже минимального).
.. rst-class:: classref-item-separator
----
.. _class_Control_method_set_anchor:
.. rst-class:: classref-method
|void| **set_anchor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, anchor\: :ref:`float<class_float>`, keep_offset\: :ref:`bool<class_bool>` = false, push_opposite_anchor\: :ref:`bool<class_bool>` = true\ ) :ref:`🔗<class_Control_method_set_anchor>`
Устанавливает якорь для указанного :ref:`Side<enum_@GlobalScope_Side>` на ``anchor``. Метод установки для :ref:`anchor_bottom<class_Control_property_anchor_bottom>`, :ref:`anchor_left<class_Control_property_anchor_left>`, :ref:`anchor_right<class_Control_property_anchor_right>` и :ref:`anchor_top<class_Control_property_anchor_top>`.
Если ``keep_offset`` равен ``true``, смещения не обновляются после этой операции.
Если ``push_opposite_anchor`` равен ``true`` и противоположный якорь перекрывает этот якорь, противоположный якорь будет иметь переопределенное значение. Например, если установить левый якорь на 1, а правый якорь имеет значение 0,5, правый якорь также получит значение 1. Если ``push_opposite_anchor`` равен ``false``, левый якорь получит значение 0,5.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_set_anchor_and_offset:
.. rst-class:: classref-method
|void| **set_anchor_and_offset**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, anchor\: :ref:`float<class_float>`, offset\: :ref:`float<class_float>`, push_opposite_anchor\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_Control_method_set_anchor_and_offset>`
Работает так же, как :ref:`set_anchor()<class_Control_method_set_anchor>`, но вместо аргумента ``keep_offset`` и автоматического обновления смещения, он позволяет установить смещение самостоятельно (см. :ref:`set_offset()<class_Control_method_set_offset>`).
.. rst-class:: classref-item-separator
----
.. _class_Control_method_set_anchors_and_offsets_preset:
.. rst-class:: classref-method
|void| **set_anchors_and_offsets_preset**\ (\ preset\: :ref:`LayoutPreset<enum_Control_LayoutPreset>`, resize_mode\: :ref:`LayoutPresetMode<enum_Control_LayoutPresetMode>` = 0, margin\: :ref:`int<class_int>` = 0\ ) :ref:`🔗<class_Control_method_set_anchors_and_offsets_preset>`
Устанавливает как предустановку якоря, так и предустановку смещения. См. :ref:`set_anchors_preset()<class_Control_method_set_anchors_preset>` и :ref:`set_offsets_preset()<class_Control_method_set_offsets_preset>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_set_anchors_preset:
.. rst-class:: classref-method
|void| **set_anchors_preset**\ (\ preset\: :ref:`LayoutPreset<enum_Control_LayoutPreset>`, keep_offsets\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_Control_method_set_anchors_preset>`
Устанавливает якоря на ``preset`` из :ref:`LayoutPreset<enum_Control_LayoutPreset>` enum. Это код, эквивалентный использованию меню Layout в 2D-редакторе.
Если ``keep_offsets`` равен ``true``, положение элемента управления также будет обновлено.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_set_begin:
.. rst-class:: classref-method
|void| **set_begin**\ (\ position\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Control_method_set_begin>`
Устанавливает :ref:`offset_left<class_Control_property_offset_left>` и :ref:`offset_top<class_Control_property_offset_top>` одновременно. Эквивалентно изменению :ref:`position<class_Control_property_position>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_set_drag_forwarding:
.. rst-class:: classref-method
|void| **set_drag_forwarding**\ (\ drag_func\: :ref:`Callable<class_Callable>`, can_drop_func\: :ref:`Callable<class_Callable>`, drop_func\: :ref:`Callable<class_Callable>`\ ) :ref:`🔗<class_Control_method_set_drag_forwarding>`
Устанавливает заданные вызываемые объекты для использования вместо собственных виртуальных методов перетаскивания элемента управления. Если вызываемый объект пуст, соответствующий ему виртуальный метод используется как обычно.
Аргументы для каждого вызываемого объекта должны быть точно такими же, как и соответствующие им виртуальные методы, которые будут:
- ``drag_func`` соответствует :ref:`_get_drag_data()<class_Control_private_method__get_drag_data>` и требует :ref:`Vector2<class_Vector2>`;
- ``can_drop_func`` соответствует :ref:`_can_drop_data()<class_Control_private_method__can_drop_data>` и требует как :ref:`Vector2<class_Vector2>`, так и :ref:`Variant<class_Variant>`;
- ``drop_func`` соответствует :ref:`_drop_data()<class_Control_private_method__drop_data>` и требует как :ref:`Vector2<class_Vector2>`, так и :ref:`Variant<class_Variant>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_set_drag_preview:
.. rst-class:: classref-method
|void| **set_drag_preview**\ (\ control\: :ref:`Control<class_Control>`\ ) :ref:`🔗<class_Control_method_set_drag_preview>`
Показывает заданный элемент управления на указателе мыши. Хорошее время для вызова этого метода — в :ref:`_get_drag_data()<class_Control_private_method__get_drag_data>`. Элемент управления не должен находиться в дереве сцены. Вы не должны освобождать элемент управления и не должны сохранять ссылку на элемент управления после окончания перетаскивания. Он будет автоматически удален после завершения перетаскивания.
.. tabs::
.. code-tab:: gdscript
@export var color = Color(1, 0, 0, 1)
func _get_drag_data(position):
# Используйте элемент управления, которого нет в дереве
var cpb = ColorPickerButton.new()
cpb.color = color
cpb.size = Vector2(50, 50)
set_drag_preview(cpb)
return color
.. code-tab:: csharp
[Export]
private Color _color = new Color(1, 0, 0, 1);
public override Variant _GetDragData(Vector2 atPosition)
{
// Используйте элемент управления, которого нет в дереве
var cpb = new ColorPickerButton();
cpb.Color = _color;
cpb.Size = new Vector2(50, 50);
SetDragPreview(cpb);
return _color;
}
.. rst-class:: classref-item-separator
----
.. _class_Control_method_set_end:
.. rst-class:: classref-method
|void| **set_end**\ (\ position\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Control_method_set_end>`
Устанавливает :ref:`offset_right<class_Control_property_offset_right>` и :ref:`offset_bottom<class_Control_property_offset_bottom>` одновременно.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_set_focus_neighbor:
.. rst-class:: classref-method
|void| **set_focus_neighbor**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, neighbor\: :ref:`NodePath<class_NodePath>`\ ) :ref:`🔗<class_Control_method_set_focus_neighbor>`
Устанавливает соседа фокуса для указанного :ref:`Side<enum_@GlobalScope_Side>` на **Control** в ``neighbor`` пути узла. Метод установки для :ref:`focus_neighbor_bottom<class_Control_property_focus_neighbor_bottom>`, :ref:`focus_neighbor_left<class_Control_property_focus_neighbor_left>`, :ref:`focus_neighbor_right<class_Control_property_focus_neighbor_right>` и :ref:`focus_neighbor_top<class_Control_property_focus_neighbor_top>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_set_global_position:
.. rst-class:: classref-method
|void| **set_global_position**\ (\ position\: :ref:`Vector2<class_Vector2>`, keep_offsets\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_Control_method_set_global_position>`
Устанавливает :ref:`global_position<class_Control_property_global_position>` на заданное ``position``.
Если ``keep_offsets`` равно ``true``, вместо смещений будут обновлены якоря элемента управления.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_set_offset:
.. rst-class:: classref-method
|void| **set_offset**\ (\ side\: :ref:`Side<enum_@GlobalScope_Side>`, offset\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Control_method_set_offset>`
Устанавливает смещение для указанного :ref:`Side<enum_@GlobalScope_Side>` на ``offset``. Метод установки для :ref:`offset_bottom<class_Control_property_offset_bottom>`, :ref:`offset_left<class_Control_property_offset_left>`, :ref:`offset_right<class_Control_property_offset_right>` и :ref:`offset_top<class_Control_property_offset_top>`.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_set_offsets_preset:
.. rst-class:: classref-method
|void| **set_offsets_preset**\ (\ preset\: :ref:`LayoutPreset<enum_Control_LayoutPreset>`, resize_mode\: :ref:`LayoutPresetMode<enum_Control_LayoutPresetMode>` = 0, margin\: :ref:`int<class_int>` = 0\ ) :ref:`🔗<class_Control_method_set_offsets_preset>`
Устанавливает смещения на ``preset`` из :ref:`LayoutPreset<enum_Control_LayoutPreset>`. Это код, эквивалентный использованию меню Layout в 2D-редакторе.
Используйте параметр ``resize_mode`` с константами из :ref:`LayoutPresetMode<enum_Control_LayoutPresetMode>`, чтобы лучше определить результирующий размер **Control**. Постоянный размер будет игнорироваться, если используется с предустановками, которые изменяют размер, например, :ref:`PRESET_LEFT_WIDE<class_Control_constant_PRESET_LEFT_WIDE>`.
Используйте параметр ``margin``, чтобы определить зазор между **Control** и краями.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_set_position:
.. rst-class:: classref-method
|void| **set_position**\ (\ position\: :ref:`Vector2<class_Vector2>`, keep_offsets\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_Control_method_set_position>`
Устанавливает :ref:`position<class_Control_property_position>` на заданное ``position``.
Если ``keep_offsets`` равно ``true``, то вместо смещений будут обновлены якоря элемента управления.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_set_size:
.. rst-class:: classref-method
|void| **set_size**\ (\ size\: :ref:`Vector2<class_Vector2>`, keep_offsets\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_Control_method_set_size>`
Устанавливает размер (см. :ref:`size<class_Control_property_size>`).
Если ``keep_offsets`` равен ``true``, вместо смещений будут обновлены якоря элемента управления.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_update_minimum_size:
.. rst-class:: classref-method
|void| **update_minimum_size**\ (\ ) :ref:`🔗<class_Control_method_update_minimum_size>`
Делает недействительным кэш размера в этом узле и в родительских узлах до верхнего уровня. Предназначено для использования с :ref:`get_minimum_size()<class_Control_method_get_minimum_size>` при изменении возвращаемого значения. Установка :ref:`custom_minimum_size<class_Control_property_custom_minimum_size>` напрямую вызывает этот метод автоматически.
.. rst-class:: classref-item-separator
----
.. _class_Control_method_warp_mouse:
.. rst-class:: classref-method
|void| **warp_mouse**\ (\ position\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Control_method_warp_mouse>`
Перемещает курсор мыши в ``position``, относительно :ref:`position<class_Control_property_position>` этого **Control**.
\ **Примечание:** :ref:`warp_mouse()<class_Control_method_warp_mouse>` поддерживается только в Windows, macOS и Linux. Он не действует на Android, iOS и Web.
.. |virtual| replace:: :abbr:`virtual (Этот метод обычно должен быть переопределен пользователем, чтобы иметь какой-либо эффект.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Этот метод не имеет побочных эффектов. Он не изменяет ни одну из переменных-членов экземпляра.)`
.. |vararg| replace:: :abbr:`vararg (Этот метод принимает любое количество аргументов после описанных здесь.)`
.. |constructor| replace:: :abbr:`constructor (Этот метод используется для создания типа.)`
.. |static| replace:: :abbr:`static (Этот метод не нуждается в вызове экземпляра, поэтому его можно вызвать напрямую, используя имя класса.)`
.. |operator| replace:: :abbr:`operator (Этот метод описывает допустимый оператор для использования с этим типом в качестве левого операнда.)`
.. |bitfield| replace:: :abbr:`BitField (Это значение является целым числом, составленным как битовая маска следующих флагов.)`
.. |void| replace:: :abbr:`void (Нет возвращаемого значения.)`
Reference in New Issue View Git Blame Copy Permalink