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/uk/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

3823 lines
279 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:`Покажчик документації графічного інтерфейсу <../tutorials/ui/index>`
- :doc:`Власне малювання в 2D <../tutorials/2d/custom_drawing_in_2d>`
- :doc:`Галерея вузлів керування <../tutorials/ui/control_node_gallery>`
- :doc:`Кілька роздільних здатностей <../tutorials/rendering/multiple_resolutions>`
- `Всі демонстрації графічного інтерфейсу <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>`
Після того, як курсор мишки надходить в видиму зону контролю (або будь-який контроль дитини), яка не входить до інших Controls або Windows, надавалася його :ref:`mouse_filter<class_Control_property_mouse_filter>` дозволяє досягнути події і незалежно від того, чи зараз він зосередився або ні.
\ **Note:** :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>`
Якщо курсор миша залишає за собою видиму зону контролю (і всі функції контролю дитини), яка не входить до інших контрольних пристроїв або Windows, надавалася його :ref:`mouse_filter<class_Control_property_mouse_filter>` дозволяє досягнути події і незалежно від того, чи зараз вона зосереджена або ні.
\ **Примітка:** :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` не впливає, що контроль отримує сигнал.
\ **Примітка:** Якщо ви хочете перевірити, чи дійсно миша залишила область, ігноруючи будь-які вершини вершини, ви можете використовувати код, як це:
::
func _on_mouse_exited():
if no 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_property_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-beam мишки, коли користувач вішає вузол. І-бемовий тостер має форму схожу на "І". Він розповідає про користувача, які вони можуть виділити або вставляти текст.
.. _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``
Показати курсор мишки системи, коли користувач захопить вузол. На 90-градусний кут показує 2 двоголових стрілок. Він говорить користувача, що він може вільно переміщати елемент UI.
.. _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>`.
\ **Note:** Налаштування цього прапора дорівнює не маючи ніяких прапорів розмірів.
.. _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:`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>`
У разі, коли курсор мишки надходить у видиму зону контролю (або будь-який контроль дитини), що не входить до інших контрольних пристроїв або Windows, наданий його :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>`
Якщо курсор мишей залишає за собою видиму площу контрольного контролю (і всіх контрольних) дитини, яка не входить до інших контрольних систем або Windows, надавалася його :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.
Якщо курсор мишки надходить на видиму площу, яка не входить до інших елементів керування або Windows, надавалася її :ref:`mouse_filter<class_Control_property_mouse_filter>` дозволяє досягнути події і незалежно від того, чи вона зараз зосереджена або ні.
\ **Примітка:** :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` не впливає на який контроль отримує повідомлення.
Дивитися також :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.
Якщо курсор мишей залишає видиму площу, яка не входить до інших елементів керування або Windows, наданий її :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>`.
- На цій вершині змінено авторську тема_type_variation.
до Змінилося одне з темних об’єктів вершини.
до Вуз входить дерево сцени.
\ **Примітка:** Як оптимізація, це повідомлення не буде відправлено з змін, які відбуваються в той час як це вершина зовні сцени. Замість, всі оновлення теми можна застосувати відразу, коли вершина надходить на дерево сцени.
\ **Примітка:** Це повідомлення надійшло поряд з :ref:`Node. НЕІФІКАЦІЯ_ENTER_TREE<class_Node_constant_ НЕІФІКАЦІЯ_ENTER_TREE>`, тому якщо ви миттєво розмовляєте сцену, дочірні вузли ще не будуть ініціовані. Ви можете використовувати його, щоб налаштувати їх для цього вузла, дочірні вершини, створені з сценарію, або якщо ви хочете отримати доступ до дочірніх вузлів, доданих в редакторі, переконайтеся, що вузол готовий використовувати :ref:`Node.is_node_ready()<class_Node_method_is_node_ready>`.
::
func _notification(what):
if what == NOTIFICATION_THEME_CHANGED!
if no 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>`, який почав прокручуватися, коли перетягування прокрученої площі * з сенсорною подією *. Це повідомлення *not* надіслане при прокручуванні за допомогою прокрутки, прокручування за допомогою миші або прокручування за допомогою клавіатури / грипаду подій.
\ **Примітка:** Цей сигнал випромінюється лише на 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>`, який припинив прокручування під час перетягування прокрученої зони * з сенсорною подією *. Це повідомлення *not* надіслане при прокручуванні за допомогою прокрутки, прокручування за допомогою миші або прокручування за допомогою клавіатури / грипаду подій.
\ **Примітка:** Цей сигнал використовується тільки на 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 або навпаки. Це сповіщення поширюється на дочірні вузли керування в результаті зміни в :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 сфокусує увагу на найближчому елементі керування праворуч від нього.
.. 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) до систем, що використовуються в поточному локальному режимі.
\ **Note:** Кількість в тексті не автоматично перетворюються, це можна зробити вручну, використовуючи :ref:`ТекстServer.format_number()<class_ТекстServer_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** у параметрах імпорту 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**\ (\ )
Розкажіть, як вони повинні змінити розмір і розмістити вузол на осі 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**\ (\ )
Розкажіть, як вони повинні змінити розмір і розмістити вузол на осі 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**\ (\ )
Назва варіації типу теми, що використовується цим ``Елементом керування`` для пошуку власних елементів теми. Якщо значення порожнє, використовується назва класу вузла (наприклад, ``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:`PojectSettings.gui/timers/tooltip_delay_sec<class_PojectSettings_member_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>`. Типова підказка method :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>`, і як позицію перетягування слід використовувати поточну позицію вибраного елемента/тексту.
::
[gdscript]
func _can_drop_data(position, data):
return typeof(data) == TYPE_DICTIONARY та data.has("color")
func _drop_data(position, data):
var color = data["color"]
[/gdscript]
[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();
}
[/csharp]
[/блоки коду]
.. 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>` тощо). Він може бути використаний лише з найпростішими вузлами графічного інтерфейсу, такими як **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:");
}
}
}
Подія не спрацює, якщо
\* клацання за межами елемента керування (див. :ref:`_has_point()<class_Control_private_method__has_point>`);
\* елемент керування має :ref:`mouse_filter<class_Control_property_mouse_filter>`, встановлений у :ref:`MOUSE_FILTER_IGNORE<class_Control_constant_MOUSE_FILTER_IGNORE>`;
\* елемент керування перекрито іншим **Control**, який знаходиться над ним, але **не** має :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>`.
\ **Примітка:4** Позиція події відносно початку керування.
.. 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
# Маючи дочірній вузол мітки "MyLabel", замінимо його колір шрифту новим значенням.
$MyLabel.add_theme_color_override("font_color", Color(1, 0,5, 0))
# Скинемо колір шрифту дочірньої мітки.
$MyLabel.remove_theme_color_override("font_color")
# Крім того, його можна замінити значенням за замовчуванням із типу Label.
$MyLabel.add_theme_color_override("font_color", get_theme_color("font_color", "Label"))
.. code-tab:: csharp
// Маючи дочірній вузол мітки "MyLabel", замінимо його колір шрифту спеціальним значенням.
GetNode<Label>("MyLabel").AddThemeColorOverride("font_color", new Color(1, 0.5f, 0));
// Скинемо кольору шрифту дочірньої мітки.
GetNode<Label>("MyLabel").RemoveThemeColorOverride("font_color");
// Крім того, його можна замінити значенням за замовчуванням із типу Label.
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:`видалення_theme_font_override()<class_Control_method_видалення_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>`
Створює локальну накладну для розміру шрифту теми з вказаною ``прізвище``. Місцеві перевизнання завжди мають прецедентність при обманці темних елементів для контролю. Видалено перевипуск з :ref:`видалення_theme_font_size_override()<class_Control_method_видалення_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)
# Видаліть перевизначення поля стилів.
$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);
// Видалити перевизначення поля стилю.
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:`_bulk_theme_override()<class_Control_private_method__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>`.
\ **Примітка:** Щоб знайти наступний ``елемент керування`` на певній стороні :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:`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>` має дійсне значення ``email protected``.
Подивитися :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>` має дійсне значення ``email protected``.
Подивитися :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`` і ``theme_type``.
Подивитися :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>` має стильний елемент з вказаною ``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 overridevoid _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``, попередньо доданим методом ``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 of param``, попередньо доданим методом ``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>` або через Inspector dock.
.. 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>` або через Inspector dock.
.. 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>` або через Inspector dock.
.. 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:`набір_anchors_preset()<class_Control_method_набір_anchors_preset>` та :ref:`набір_offsets_preset()<class_Control_method_набір_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>`. Цей код еквівалентний використанню меню 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(позиція):
# Використовуйте елемент керування, якого немає в дереві
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`` цього **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