align to horizontal_alignment, valign to vertical_alignment, related

28 files changed, 317 insertions, 390 deletions

diff --git a/scene/gui/aspect_ratio_container.cpp b/scene/gui/aspect_ratio_container.cpp
index fb6fa9dec9..9526c5e793 100644
--- a/scene/gui/aspect_ratio_container.cpp
+++ b/scene/gui/aspect_ratio_container.cpp
@@ -60,12 +60,12 @@ void AspectRatioContainer::set_stretch_mode(StretchMode p_mode) {
 	queue_sort();
 }
 
-void AspectRatioContainer::set_alignment_horizontal(AlignMode p_alignment_horizontal) {
+void AspectRatioContainer::set_alignment_horizontal(AlignmentMode p_alignment_horizontal) {
 	alignment_horizontal = p_alignment_horizontal;
 	queue_sort();
 }
 
-void AspectRatioContainer::set_alignment_vertical(AlignMode p_alignment_vertical) {
+void AspectRatioContainer::set_alignment_vertical(AlignmentMode p_alignment_vertical) {
 	alignment_vertical = p_alignment_vertical;
 	queue_sort();
 }
@@ -107,25 +107,25 @@ void AspectRatioContainer::_notification(int p_what) {
 
 				float align_x = 0.5;
 				switch (alignment_horizontal) {
-					case ALIGN_BEGIN: {
+					case ALIGNMENT_BEGIN: {
 						align_x = 0.0;
 					} break;
-					case ALIGN_CENTER: {
+					case ALIGNMENT_CENTER: {
 						align_x = 0.5;
 					} break;
-					case ALIGN_END: {
+					case ALIGNMENT_END: {
 						align_x = 1.0;
 					} break;
 				}
 				float align_y = 0.5;
 				switch (alignment_vertical) {
-					case ALIGN_BEGIN: {
+					case ALIGNMENT_BEGIN: {
 						align_y = 0.0;
 					} break;
-					case ALIGN_CENTER: {
+					case ALIGNMENT_CENTER: {
 						align_y = 0.5;
 					} break;
-					case ALIGN_END: {
+					case ALIGNMENT_END: {
 						align_y = 1.0;
 					} break;
 				}
@@ -166,7 +166,7 @@ void AspectRatioContainer::_bind_methods() {
 	BIND_ENUM_CONSTANT(STRETCH_FIT);
 	BIND_ENUM_CONSTANT(STRETCH_COVER);
 
-	BIND_ENUM_CONSTANT(ALIGN_BEGIN);
-	BIND_ENUM_CONSTANT(ALIGN_CENTER);
-	BIND_ENUM_CONSTANT(ALIGN_END);
+	BIND_ENUM_CONSTANT(ALIGNMENT_BEGIN);
+	BIND_ENUM_CONSTANT(ALIGNMENT_CENTER);
+	BIND_ENUM_CONSTANT(ALIGNMENT_END);
 }
diff --git a/scene/gui/aspect_ratio_container.h b/scene/gui/aspect_ratio_container.h
index c95c6a7274..3cdfc75734 100644
--- a/scene/gui/aspect_ratio_container.h
+++ b/scene/gui/aspect_ratio_container.h
@@ -48,17 +48,17 @@ public:
 		STRETCH_FIT,
 		STRETCH_COVER,
 	};
-	enum AlignMode {
-		ALIGN_BEGIN,
-		ALIGN_CENTER,
-		ALIGN_END,
+	enum AlignmentMode {
+		ALIGNMENT_BEGIN,
+		ALIGNMENT_CENTER,
+		ALIGNMENT_END,
 	};
 
 private:
 	float ratio = 1.0;
 	StretchMode stretch_mode = STRETCH_FIT;
-	AlignMode alignment_horizontal = ALIGN_CENTER;
-	AlignMode alignment_vertical = ALIGN_CENTER;
+	AlignmentMode alignment_horizontal = ALIGNMENT_CENTER;
+	AlignmentMode alignment_vertical = ALIGNMENT_CENTER;
 
 public:
 	void set_ratio(float p_ratio);
@@ -67,14 +67,14 @@ public:
 	void set_stretch_mode(StretchMode p_mode);
 	StretchMode get_stretch_mode() const { return stretch_mode; }
 
-	void set_alignment_horizontal(AlignMode p_alignment_horizontal);
-	AlignMode get_alignment_horizontal() const { return alignment_horizontal; }
+	void set_alignment_horizontal(AlignmentMode p_alignment_horizontal);
+	AlignmentMode get_alignment_horizontal() const { return alignment_horizontal; }
 
-	void set_alignment_vertical(AlignMode p_alignment_vertical);
-	AlignMode get_alignment_vertical() const { return alignment_vertical; }
+	void set_alignment_vertical(AlignmentMode p_alignment_vertical);
+	AlignmentMode get_alignment_vertical() const { return alignment_vertical; }
 };
 
 VARIANT_ENUM_CAST(AspectRatioContainer::StretchMode);
-VARIANT_ENUM_CAST(AspectRatioContainer::AlignMode);
+VARIANT_ENUM_CAST(AspectRatioContainer::AlignmentMode);
 
 #endif // ASPECT_RATIO_CONTAINER_H
diff --git a/scene/gui/box_container.cpp b/scene/gui/box_container.cpp
index 83c392614b..fc05d51937 100644
--- a/scene/gui/box_container.cpp
+++ b/scene/gui/box_container.cpp
@@ -154,29 +154,29 @@ void BoxContainer::_resort() {
 	int ofs = 0;
 	if (!has_stretched) {
 		if (!vertical) {
-			switch (align) {
-				case ALIGN_BEGIN:
+			switch (alignment) {
+				case ALIGNMENT_BEGIN:
 					if (rtl) {
 						ofs = stretch_diff;
 					}
 					break;
-				case ALIGN_CENTER:
+				case ALIGNMENT_CENTER:
 					ofs = stretch_diff / 2;
 					break;
-				case ALIGN_END:
+				case ALIGNMENT_END:
 					if (!rtl) {
 						ofs = stretch_diff;
 					}
 					break;
 			}
 		} else {
-			switch (align) {
-				case ALIGN_BEGIN:
+			switch (alignment) {
+				case ALIGNMENT_BEGIN:
 					break;
-				case ALIGN_CENTER:
+				case ALIGNMENT_CENTER:
 					ofs = stretch_diff / 2;
 					break;
-				case ALIGN_END:
+				case ALIGNMENT_END:
 					ofs = stretch_diff;
 					break;
 			}
@@ -304,13 +304,13 @@ void BoxContainer::_notification(int p_what) {
 	}
 }
 
-void BoxContainer::set_alignment(AlignMode p_align) {
-	align = p_align;
+void BoxContainer::set_alignment(AlignmentMode p_alignment) {
+	alignment = p_alignment;
 	_resort();
 }
 
-BoxContainer::AlignMode BoxContainer::get_alignment() const {
-	return align;
+BoxContainer::AlignmentMode BoxContainer::get_alignment() const {
+	return alignment;
 }
 
 Control *BoxContainer::add_spacer(bool p_begin) {
@@ -340,9 +340,9 @@ void BoxContainer::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_alignment"), &BoxContainer::get_alignment);
 	ClassDB::bind_method(D_METHOD("set_alignment", "alignment"), &BoxContainer::set_alignment);
 
-	BIND_ENUM_CONSTANT(ALIGN_BEGIN);
-	BIND_ENUM_CONSTANT(ALIGN_CENTER);
-	BIND_ENUM_CONSTANT(ALIGN_END);
+	BIND_ENUM_CONSTANT(ALIGNMENT_BEGIN);
+	BIND_ENUM_CONSTANT(ALIGNMENT_CENTER);
+	BIND_ENUM_CONSTANT(ALIGNMENT_END);
 
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "alignment", PROPERTY_HINT_ENUM, "Begin,Center,End"), "set_alignment", "get_alignment");
 }
diff --git a/scene/gui/box_container.h b/scene/gui/box_container.h
index 23feea565c..9bb26ec32c 100644
--- a/scene/gui/box_container.h
+++ b/scene/gui/box_container.h
@@ -37,15 +37,15 @@ class BoxContainer : public Container {
 	GDCLASS(BoxContainer, Container);
 
 public:
-	enum AlignMode {
-		ALIGN_BEGIN,
-		ALIGN_CENTER,
-		ALIGN_END
+	enum AlignmentMode {
+		ALIGNMENT_BEGIN,
+		ALIGNMENT_CENTER,
+		ALIGNMENT_END
 	};
 
 private:
 	bool vertical = false;
-	AlignMode align = ALIGN_BEGIN;
+	AlignmentMode alignment = ALIGNMENT_BEGIN;
 
 	void _resort();
 
@@ -57,8 +57,8 @@ protected:
 public:
 	Control *add_spacer(bool p_begin = false);
 
-	void set_alignment(AlignMode p_align);
-	AlignMode get_alignment() const;
+	void set_alignment(AlignmentMode p_alignment);
+	AlignmentMode get_alignment() const;
 
 	virtual Size2 get_minimum_size() const override;
 
@@ -84,6 +84,6 @@ public:
 			BoxContainer(true) {}
 };
 
-VARIANT_ENUM_CAST(BoxContainer::AlignMode);
+VARIANT_ENUM_CAST(BoxContainer::AlignmentMode);
 
 #endif // BOX_CONTAINER_H
diff --git a/scene/gui/button.cpp b/scene/gui/button.cpp
index 2932707401..655fc783d7 100644
--- a/scene/gui/button.cpp
+++ b/scene/gui/button.cpp
@@ -50,7 +50,7 @@ Size2 Button::get_minimum_size() const {
 		if (!_icon.is_null()) {
 			minsize.height = MAX(minsize.height, _icon->get_height());
 
-			if (icon_align != ALIGN_CENTER) {
+			if (icon_alignment != HORIZONTAL_ALIGNMENT_CENTER) {
 				minsize.width += _icon->get_width();
 				if (xl_text != "") {
 					minsize.width += get_theme_constant(SNAME("hseparation"));
@@ -216,19 +216,19 @@ void Button::_notification(int p_what) {
 			}
 
 			Rect2 icon_region = Rect2();
-			TextAlign icon_align_rtl_checked = icon_align;
-			TextAlign align_rtl_checked = align;
+			HorizontalAlignment icon_align_rtl_checked = icon_alignment;
+			HorizontalAlignment align_rtl_checked = alignment;
 			// Swap icon and text alignment sides if right-to-left layout is set.
 			if (rtl) {
-				if (icon_align == ALIGN_RIGHT) {
-					icon_align_rtl_checked = ALIGN_LEFT;
-				} else if (icon_align == ALIGN_LEFT) {
-					icon_align_rtl_checked = ALIGN_RIGHT;
+				if (icon_alignment == HORIZONTAL_ALIGNMENT_RIGHT) {
+					icon_align_rtl_checked = HORIZONTAL_ALIGNMENT_LEFT;
+				} else if (icon_alignment == HORIZONTAL_ALIGNMENT_LEFT) {
+					icon_align_rtl_checked = HORIZONTAL_ALIGNMENT_RIGHT;
 				}
-				if (align == ALIGN_RIGHT) {
-					align_rtl_checked = ALIGN_LEFT;
-				} else if (align == ALIGN_LEFT) {
-					align_rtl_checked = ALIGN_RIGHT;
+				if (alignment == HORIZONTAL_ALIGNMENT_RIGHT) {
+					align_rtl_checked = HORIZONTAL_ALIGNMENT_LEFT;
+				} else if (alignment == HORIZONTAL_ALIGNMENT_LEFT) {
+					align_rtl_checked = HORIZONTAL_ALIGNMENT_RIGHT;
 				}
 			}
 			if (!_icon.is_null()) {
@@ -240,14 +240,14 @@ void Button::_notification(int p_what) {
 				float icon_ofs_region = 0.0;
 				Point2 style_offset;
 				Size2 icon_size = _icon->get_size();
-				if (icon_align_rtl_checked == ALIGN_LEFT) {
+				if (icon_align_rtl_checked == HORIZONTAL_ALIGNMENT_LEFT) {
 					style_offset.x = style->get_margin(SIDE_LEFT);
 					if (_internal_margin[SIDE_LEFT] > 0) {
 						icon_ofs_region = _internal_margin[SIDE_LEFT] + get_theme_constant(SNAME("hseparation"));
 					}
-				} else if (icon_align_rtl_checked == ALIGN_CENTER) {
+				} else if (icon_align_rtl_checked == HORIZONTAL_ALIGNMENT_CENTER) {
 					style_offset.x = 0.0;
-				} else if (icon_align_rtl_checked == ALIGN_RIGHT) {
+				} else if (icon_align_rtl_checked == HORIZONTAL_ALIGNMENT_RIGHT) {
 					style_offset.x = -style->get_margin(SIDE_RIGHT);
 					if (_internal_margin[SIDE_RIGHT] > 0) {
 						icon_ofs_region = -_internal_margin[SIDE_RIGHT] - get_theme_constant(SNAME("hseparation"));
@@ -258,7 +258,7 @@ void Button::_notification(int p_what) {
 				if (expand_icon) {
 					Size2 _size = get_size() - style->get_offset() * 2;
 					_size.width -= get_theme_constant(SNAME("hseparation")) + icon_ofs_region;
-					if (!clip_text && icon_align_rtl_checked != ALIGN_CENTER) {
+					if (!clip_text && icon_align_rtl_checked != HORIZONTAL_ALIGNMENT_CENTER) {
 						_size.width -= text_buf->get_size().width;
 					}
 					float icon_width = _icon->get_width() * _size.height / _icon->get_height();
@@ -272,9 +272,9 @@ void Button::_notification(int p_what) {
 					icon_size = Size2(icon_width, icon_height);
 				}
 
-				if (icon_align_rtl_checked == ALIGN_LEFT) {
+				if (icon_align_rtl_checked == HORIZONTAL_ALIGNMENT_LEFT) {
 					icon_region = Rect2(style_offset + Point2(icon_ofs_region, Math::floor((valign - icon_size.y) * 0.5)), icon_size);
-				} else if (icon_align_rtl_checked == ALIGN_CENTER) {
+				} else if (icon_align_rtl_checked == HORIZONTAL_ALIGNMENT_CENTER) {
 					icon_region = Rect2(style_offset + Point2(icon_ofs_region + Math::floor((size.x - icon_size.x) * 0.5), Math::floor((valign - icon_size.y) * 0.5)), icon_size);
 				} else {
 					icon_region = Rect2(style_offset + Point2(icon_ofs_region + size.x - icon_size.x, Math::floor((valign - icon_size.y) * 0.5)), icon_size);
@@ -286,7 +286,7 @@ void Button::_notification(int p_what) {
 			}
 
 			Point2 icon_ofs = !_icon.is_null() ? Point2(icon_region.size.width + get_theme_constant(SNAME("hseparation")), 0) : Point2();
-			if (align_rtl_checked == ALIGN_CENTER && icon_align_rtl_checked == ALIGN_CENTER) {
+			if (align_rtl_checked == HORIZONTAL_ALIGNMENT_CENTER && icon_align_rtl_checked == HORIZONTAL_ALIGNMENT_CENTER) {
 				icon_ofs.x = 0.0;
 			}
 			int text_clip = size.width - style->get_minimum_size().width - icon_ofs.width;
@@ -304,8 +304,9 @@ void Button::_notification(int p_what) {
 			Point2 text_ofs = (size - style->get_minimum_size() - icon_ofs - text_buf->get_size() - Point2(_internal_margin[SIDE_RIGHT] - _internal_margin[SIDE_LEFT], 0)) / 2.0;
 
 			switch (align_rtl_checked) {
-				case ALIGN_LEFT: {
-					if (icon_align_rtl_checked != ALIGN_LEFT) {
+				case HORIZONTAL_ALIGNMENT_FILL:
+				case HORIZONTAL_ALIGNMENT_LEFT: {
+					if (icon_align_rtl_checked != HORIZONTAL_ALIGNMENT_LEFT) {
 						icon_ofs.x = 0.0;
 					}
 					if (_internal_margin[SIDE_LEFT] > 0) {
@@ -315,23 +316,23 @@ void Button::_notification(int p_what) {
 					}
 					text_ofs.y += style->get_offset().y;
 				} break;
-				case ALIGN_CENTER: {
+				case HORIZONTAL_ALIGNMENT_CENTER: {
 					if (text_ofs.x < 0) {
 						text_ofs.x = 0;
 					}
-					if (icon_align_rtl_checked == ALIGN_LEFT) {
+					if (icon_align_rtl_checked == HORIZONTAL_ALIGNMENT_LEFT) {
 						text_ofs += icon_ofs;
 					}
 					text_ofs += style->get_offset();
 				} break;
-				case ALIGN_RIGHT: {
+				case HORIZONTAL_ALIGNMENT_RIGHT: {
 					if (_internal_margin[SIDE_RIGHT] > 0) {
 						text_ofs.x = size.x - style->get_margin(SIDE_RIGHT) - text_width - _internal_margin[SIDE_RIGHT] - get_theme_constant(SNAME("hseparation"));
 					} else {
 						text_ofs.x = size.x - style->get_margin(SIDE_RIGHT) - text_width;
 					}
 					text_ofs.y += style->get_offset().y;
-					if (icon_align_rtl_checked == ALIGN_RIGHT) {
+					if (icon_align_rtl_checked == HORIZONTAL_ALIGNMENT_RIGHT) {
 						text_ofs.x -= icon_ofs.x;
 					}
 				} break;
@@ -471,25 +472,25 @@ bool Button::get_clip_text() const {
 	return clip_text;
 }
 
-void Button::set_text_align(TextAlign p_align) {
-	if (align != p_align) {
-		align = p_align;
+void Button::set_text_alignment(HorizontalAlignment p_alignment) {
+	if (alignment != p_alignment) {
+		alignment = p_alignment;
 		update();
 	}
 }
 
-Button::TextAlign Button::get_text_align() const {
-	return align;
+HorizontalAlignment Button::get_text_alignment() const {
+	return alignment;
 }
 
-void Button::set_icon_align(TextAlign p_align) {
-	icon_align = p_align;
+void Button::set_icon_alignment(HorizontalAlignment p_alignment) {
+	icon_alignment = p_alignment;
 	update_minimum_size();
 	update();
 }
 
-Button::TextAlign Button::get_icon_align() const {
-	return icon_align;
+HorizontalAlignment Button::get_icon_alignment() const {
+	return icon_alignment;
 }
 
 bool Button::_set(const StringName &p_name, const Variant &p_value) {
@@ -558,25 +559,21 @@ void Button::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("is_flat"), &Button::is_flat);
 	ClassDB::bind_method(D_METHOD("set_clip_text", "enabled"), &Button::set_clip_text);
 	ClassDB::bind_method(D_METHOD("get_clip_text"), &Button::get_clip_text);
-	ClassDB::bind_method(D_METHOD("set_text_align", "align"), &Button::set_text_align);
-	ClassDB::bind_method(D_METHOD("get_text_align"), &Button::get_text_align);
-	ClassDB::bind_method(D_METHOD("set_icon_align", "icon_align"), &Button::set_icon_align);
-	ClassDB::bind_method(D_METHOD("get_icon_align"), &Button::get_icon_align);
+	ClassDB::bind_method(D_METHOD("set_text_alignment", "alignment"), &Button::set_text_alignment);
+	ClassDB::bind_method(D_METHOD("get_text_alignment"), &Button::get_text_alignment);
+	ClassDB::bind_method(D_METHOD("set_icon_alignment", "icon_alignment"), &Button::set_icon_alignment);
+	ClassDB::bind_method(D_METHOD("get_icon_alignment"), &Button::get_icon_alignment);
 	ClassDB::bind_method(D_METHOD("set_expand_icon", "enabled"), &Button::set_expand_icon);
 	ClassDB::bind_method(D_METHOD("is_expand_icon"), &Button::is_expand_icon);
 
-	BIND_ENUM_CONSTANT(ALIGN_LEFT);
-	BIND_ENUM_CONSTANT(ALIGN_CENTER);
-	BIND_ENUM_CONSTANT(ALIGN_RIGHT);
-
 	ADD_PROPERTY(PropertyInfo(Variant::STRING, "text", PROPERTY_HINT_MULTILINE_TEXT, "", PROPERTY_USAGE_DEFAULT_INTL), "set_text", "get_text");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "text_direction", PROPERTY_HINT_ENUM, "Auto,Left-to-Right,Right-to-Left,Inherited"), "set_text_direction", "get_text_direction");
 	ADD_PROPERTY(PropertyInfo(Variant::STRING, "language"), "set_language", "get_language");
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "icon", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_button_icon", "get_button_icon");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "flat"), "set_flat", "is_flat");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "clip_text"), "set_clip_text", "get_clip_text");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "align", PROPERTY_HINT_ENUM, "Left,Center,Right"), "set_text_align", "get_text_align");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "icon_align", PROPERTY_HINT_ENUM, "Left,Center,Right"), "set_icon_align", "get_icon_align");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "alignment", PROPERTY_HINT_ENUM, "Left,Center,Right"), "set_text_alignment", "get_text_alignment");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "icon_alignment", PROPERTY_HINT_ENUM, "Left,Center,Right"), "set_icon_alignment", "get_icon_alignment");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "expand_icon"), "set_expand_icon", "is_expand_icon");
 }
 
diff --git a/scene/gui/button.h b/scene/gui/button.h
index fd36cb77af..92d86542a6 100644
--- a/scene/gui/button.h
+++ b/scene/gui/button.h
@@ -37,13 +37,6 @@
 class Button : public BaseButton {
 	GDCLASS(Button, BaseButton);
 
-public:
-	enum TextAlign {
-		ALIGN_LEFT,
-		ALIGN_CENTER,
-		ALIGN_RIGHT
-	};
-
 private:
 	bool flat = false;
 	String text;
@@ -57,8 +50,8 @@ private:
 	Ref<Texture2D> icon;
 	bool expand_icon = false;
 	bool clip_text = false;
-	TextAlign align = ALIGN_CENTER;
-	TextAlign icon_align = ALIGN_LEFT;
+	HorizontalAlignment alignment = HORIZONTAL_ALIGNMENT_CENTER;
+	HorizontalAlignment icon_alignment = HORIZONTAL_ALIGNMENT_LEFT;
 	float _internal_margin[4] = {};
 
 	void _shape();
@@ -100,16 +93,14 @@ public:
 	void set_clip_text(bool p_enabled);
 	bool get_clip_text() const;
 
-	void set_text_align(TextAlign p_align);
-	TextAlign get_text_align() const;
+	void set_text_alignment(HorizontalAlignment p_alignment);
+	HorizontalAlignment get_text_alignment() const;
 
-	void set_icon_align(TextAlign p_align);
-	TextAlign get_icon_align() const;
+	void set_icon_alignment(HorizontalAlignment p_alignment);
+	HorizontalAlignment get_icon_alignment() const;
 
 	Button(const String &p_text = String());
 	~Button();
 };
 
-VARIANT_ENUM_CAST(Button::TextAlign);
-
 #endif
diff --git a/scene/gui/check_box.cpp b/scene/gui/check_box.cpp
index 411fb2e1f0..134766b05f 100644
--- a/scene/gui/check_box.cpp
+++ b/scene/gui/check_box.cpp
@@ -123,7 +123,7 @@ CheckBox::CheckBox(const String &p_text) :
 		Button(p_text) {
 	set_toggle_mode(true);
 
-	set_text_align(ALIGN_LEFT);
+	set_text_alignment(HORIZONTAL_ALIGNMENT_LEFT);
 
 	if (is_layout_rtl()) {
 		_set_internal_margin(SIDE_RIGHT, get_icon_size().width);
diff --git a/scene/gui/check_button.cpp b/scene/gui/check_button.cpp
index 162a256d23..499bedda52 100644
--- a/scene/gui/check_button.cpp
+++ b/scene/gui/check_button.cpp
@@ -107,7 +107,7 @@ void CheckButton::_notification(int p_what) {
 
 CheckButton::CheckButton() {
 	set_toggle_mode(true);
-	set_text_align(ALIGN_LEFT);
+	set_text_alignment(HORIZONTAL_ALIGNMENT_LEFT);
 	if (is_layout_rtl()) {
 		_set_internal_margin(SIDE_LEFT, get_icon_size().width);
 	} else {
diff --git a/scene/gui/code_edit.cpp b/scene/gui/code_edit.cpp
index a8c5966569..23ac36c5eb 100644
--- a/scene/gui/code_edit.cpp
+++ b/scene/gui/code_edit.cpp
@@ -170,12 +170,12 @@ void CodeEdit::_notification(int p_what) {
 						if (code_completion_options[l].default_value.get_type() == Variant::COLOR) {
 							draw_rect(Rect2(Point2(code_completion_rect.position.x, icon_area.position.y), icon_area_size), (Color)code_completion_options[l].default_value);
 						}
-						tl->set_align(HALIGN_RIGHT);
+						tl->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_RIGHT);
 					} else {
 						if (code_completion_options[l].default_value.get_type() == Variant::COLOR) {
 							draw_rect(Rect2(Point2(code_completion_rect.position.x + code_completion_rect.size.width - icon_area_size.x, icon_area.position.y), icon_area_size), (Color)code_completion_options[l].default_value);
 						}
-						tl->set_align(HALIGN_LEFT);
+						tl->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_LEFT);
 					}
 					tl->draw(ci, title_pos, code_completion_options[l].font_color);
 				}
@@ -229,7 +229,7 @@ void CodeEdit::_notification(int p_what) {
 
 					Point2 round_ofs = hint_ofs + sb->get_offset() + Vector2(0, font->get_ascent(font_size) + font_height * i + yofs);
 					round_ofs = round_ofs.round();
-					draw_string(font, round_ofs, line.replace(String::chr(0xFFFF), ""), HALIGN_LEFT, -1, font_size, font_color);
+					draw_string(font, round_ofs, line.replace(String::chr(0xFFFF), ""), HORIZONTAL_ALIGNMENT_LEFT, -1, font_size, font_color);
 					if (end > 0) {
 						// Draw an underline for the currently edited function parameter.
 						const Vector2 b = hint_ofs + sb->get_offset() + Vector2(begin, font_height + font_height * i + yofs);
diff --git a/scene/gui/color_picker.cpp b/scene/gui/color_picker.cpp
index 5a378554c9..63ffe7bf95 100644
--- a/scene/gui/color_picker.cpp
+++ b/scene/gui/color_picker.cpp
@@ -1274,7 +1274,7 @@ ColorPicker::ColorPicker() :
 	preset_container->set_columns(preset_column_count);
 	add_child(preset_container, false, INTERNAL_MODE_FRONT);
 
-	btn_add_preset->set_icon_align(Button::ALIGN_CENTER);
+	btn_add_preset->set_icon_alignment(HORIZONTAL_ALIGNMENT_CENTER);
 	btn_add_preset->set_tooltip(RTR("Add current color as a preset."));
 	btn_add_preset->connect("pressed", callable_mp(this, &ColorPicker::_add_preset_pressed));
 	preset_container->add_child(btn_add_preset);
diff --git a/scene/gui/file_dialog.cpp b/scene/gui/file_dialog.cpp
index e3754c4d38..08d5df3db8 100644
--- a/scene/gui/file_dialog.cpp
+++ b/scene/gui/file_dialog.cpp
@@ -1000,8 +1000,8 @@ FileDialog::FileDialog() {
 	message = memnew(Label);
 	message->hide();
 	message->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
-	message->set_align(Label::ALIGN_CENTER);
-	message->set_valign(Label::VALIGN_CENTER);
+	message->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_CENTER);
+	message->set_vertical_alignment(VERTICAL_ALIGNMENT_CENTER);
 	tree->add_child(message);
 
 	file_box = memnew(HBoxContainer);
diff --git a/scene/gui/graph_edit.cpp b/scene/gui/graph_edit.cpp
index b0050f028b..32c62b7226 100644
--- a/scene/gui/graph_edit.cpp
+++ b/scene/gui/graph_edit.cpp
@@ -2312,7 +2312,7 @@ GraphEdit::GraphEdit() {
 	zoom_hb->add_child(zoom_label);
 	zoom_label->set_visible(false);
 	zoom_label->set_v_size_flags(Control::SIZE_SHRINK_CENTER);
-	zoom_label->set_align(Label::ALIGN_CENTER);
+	zoom_label->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_CENTER);
 	zoom_label->set_custom_minimum_size(Size2(48, 0));
 	_update_zoom_label();
 
diff --git a/scene/gui/item_list.cpp b/scene/gui/item_list.cpp
index 857058f94e..a3235dd382 100644
--- a/scene/gui/item_list.cpp
+++ b/scene/gui/item_list.cpp
@@ -1213,7 +1213,7 @@ void ItemList::_notification(int p_what) {
 						text_ofs.x = size.width - text_ofs.x - max_len;
 					}
 
-					items.write[i].text_buf->set_align(HALIGN_CENTER);
+					items.write[i].text_buf->set_alignment(HORIZONTAL_ALIGNMENT_CENTER);
 
 					if (outline_size > 0 && font_outline_color.a > 0) {
 						items[i].text_buf->draw_outline(get_canvas_item(), text_ofs, outline_size, font_outline_color);
@@ -1241,9 +1241,9 @@ void ItemList::_notification(int p_what) {
 					items.write[i].text_buf->set_width(max_len);
 
 					if (rtl) {
-						items.write[i].text_buf->set_align(HALIGN_RIGHT);
+						items.write[i].text_buf->set_alignment(HORIZONTAL_ALIGNMENT_RIGHT);
 					} else {
-						items.write[i].text_buf->set_align(HALIGN_LEFT);
+						items.write[i].text_buf->set_alignment(HORIZONTAL_ALIGNMENT_LEFT);
 					}
 
 					if (outline_size > 0 && font_outline_color.a > 0) {
diff --git a/scene/gui/label.cpp b/scene/gui/label.cpp
index 3e1b9c9ceb..bd3a2c2e53 100644
--- a/scene/gui/label.cpp
+++ b/scene/gui/label.cpp
@@ -175,7 +175,7 @@ void Label::_shape() {
 			if (lines_hidden) {
 				overrun_flags |= TextServer::OVERRUN_ENFORCE_ELLIPSIS;
 			}
-			if (align == ALIGN_FILL) {
+			if (horizontal_alignment == HORIZONTAL_ALIGNMENT_FILL) {
 				for (int i = 0; i < lines_rid.size(); i++) {
 					if (i < visible_lines - 1 || lines_rid.size() == 1) {
 						TS->shaped_text_fit_to_width(lines_rid[i], width);
@@ -191,7 +191,7 @@ void Label::_shape() {
 		} else {
 			// Autowrap disabled.
 			for (int i = 0; i < lines_rid.size(); i++) {
-				if (align == ALIGN_FILL) {
+				if (horizontal_alignment == HORIZONTAL_ALIGNMENT_FILL) {
 					TS->shaped_text_fit_to_width(lines_rid[i], width);
 					overrun_flags |= TextServer::OVERRUN_JUSTIFICATION_AWARE;
 					TS->shaped_text_overrun_trim_to_width(lines_rid[i], width, overrun_flags);
@@ -326,21 +326,21 @@ void Label::_notification(int p_what) {
 
 		int vbegin = 0, vsep = 0;
 		if (lines_visible > 0) {
-			switch (valign) {
-				case VALIGN_TOP: {
+			switch (vertical_alignment) {
+				case VERTICAL_ALIGNMENT_TOP: {
 					// Nothing.
 				} break;
-				case VALIGN_CENTER: {
+				case VERTICAL_ALIGNMENT_CENTER: {
 					vbegin = (size.y - (total_h - line_spacing)) / 2;
 					vsep = 0;
 
 				} break;
-				case VALIGN_BOTTOM: {
+				case VERTICAL_ALIGNMENT_BOTTOM: {
 					vbegin = size.y - (total_h - line_spacing);
 					vsep = 0;
 
 				} break;
-				case VALIGN_FILL: {
+				case VERTICAL_ALIGNMENT_FILL: {
 					vbegin = 0;
 					if (lines_visible > 1) {
 						vsep = (size.y - (total_h - line_spacing)) / (lines_visible - 1);
@@ -358,25 +358,25 @@ void Label::_notification(int p_what) {
 			Size2 line_size = TS->shaped_text_get_size(lines_rid[i]);
 			ofs.x = 0;
 			ofs.y += TS->shaped_text_get_ascent(lines_rid[i]) + font->get_spacing(TextServer::SPACING_TOP);
-			switch (align) {
-				case ALIGN_FILL:
+			switch (horizontal_alignment) {
+				case HORIZONTAL_ALIGNMENT_FILL:
 					if (rtl && autowrap_mode != AUTOWRAP_OFF) {
 						ofs.x = int(size.width - style->get_margin(SIDE_RIGHT) - line_size.width);
 					} else {
 						ofs.x = style->get_offset().x;
 					}
 					break;
-				case ALIGN_LEFT: {
+				case HORIZONTAL_ALIGNMENT_LEFT: {
 					if (rtl_layout) {
 						ofs.x = int(size.width - style->get_margin(SIDE_RIGHT) - line_size.width);
 					} else {
 						ofs.x = style->get_offset().x;
 					}
 				} break;
-				case ALIGN_CENTER: {
+				case HORIZONTAL_ALIGNMENT_CENTER: {
 					ofs.x = int(size.width - line_size.width) / 2;
 				} break;
-				case ALIGN_RIGHT: {
+				case HORIZONTAL_ALIGNMENT_RIGHT: {
 					if (rtl_layout) {
 						ofs.x = style->get_offset().x;
 					} else {
@@ -556,29 +556,29 @@ int Label::get_visible_line_count() const {
 	return lines_visible;
 }
 
-void Label::set_align(Align p_align) {
-	ERR_FAIL_INDEX((int)p_align, 4);
-	if (align != p_align) {
-		if (align == ALIGN_FILL || p_align == ALIGN_FILL) {
+void Label::set_horizontal_alignment(HorizontalAlignment p_alignment) {
+	ERR_FAIL_INDEX((int)p_alignment, 4);
+	if (horizontal_alignment != p_alignment) {
+		if (horizontal_alignment == HORIZONTAL_ALIGNMENT_FILL || p_alignment == HORIZONTAL_ALIGNMENT_FILL) {
 			lines_dirty = true; // Reshape lines.
 		}
-		align = p_align;
+		horizontal_alignment = p_alignment;
 	}
 	update();
 }
 
-Label::Align Label::get_align() const {
-	return align;
+HorizontalAlignment Label::get_horizontal_alignment() const {
+	return horizontal_alignment;
 }
 
-void Label::set_valign(VAlign p_align) {
-	ERR_FAIL_INDEX((int)p_align, 4);
-	valign = p_align;
+void Label::set_vertical_alignment(VerticalAlignment p_alignment) {
+	ERR_FAIL_INDEX((int)p_alignment, 4);
+	vertical_alignment = p_alignment;
 	update();
 }
 
-Label::VAlign Label::get_valign() const {
-	return valign;
+VerticalAlignment Label::get_vertical_alignment() const {
+	return vertical_alignment;
 }
 
 void Label::set_text(const String &p_string) {
@@ -809,10 +809,10 @@ void Label::_get_property_list(List<PropertyInfo> *p_list) const {
 }
 
 void Label::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_align", "align"), &Label::set_align);
-	ClassDB::bind_method(D_METHOD("get_align"), &Label::get_align);
-	ClassDB::bind_method(D_METHOD("set_valign", "valign"), &Label::set_valign);
-	ClassDB::bind_method(D_METHOD("get_valign"), &Label::get_valign);
+	ClassDB::bind_method(D_METHOD("set_horizontal_alignment", "alignment"), &Label::set_horizontal_alignment);
+	ClassDB::bind_method(D_METHOD("get_horizontal_alignment"), &Label::get_horizontal_alignment);
+	ClassDB::bind_method(D_METHOD("set_vertical_alignment", "alignment"), &Label::set_vertical_alignment);
+	ClassDB::bind_method(D_METHOD("get_vertical_alignment"), &Label::get_vertical_alignment);
 	ClassDB::bind_method(D_METHOD("set_text", "text"), &Label::set_text);
 	ClassDB::bind_method(D_METHOD("get_text"), &Label::get_text);
 	ClassDB::bind_method(D_METHOD("set_text_direction", "direction"), &Label::set_text_direction);
@@ -847,16 +847,6 @@ void Label::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_structured_text_bidi_override_options", "args"), &Label::set_structured_text_bidi_override_options);
 	ClassDB::bind_method(D_METHOD("get_structured_text_bidi_override_options"), &Label::get_structured_text_bidi_override_options);
 
-	BIND_ENUM_CONSTANT(ALIGN_LEFT);
-	BIND_ENUM_CONSTANT(ALIGN_CENTER);
-	BIND_ENUM_CONSTANT(ALIGN_RIGHT);
-	BIND_ENUM_CONSTANT(ALIGN_FILL);
-
-	BIND_ENUM_CONSTANT(VALIGN_TOP);
-	BIND_ENUM_CONSTANT(VALIGN_CENTER);
-	BIND_ENUM_CONSTANT(VALIGN_BOTTOM);
-	BIND_ENUM_CONSTANT(VALIGN_FILL);
-
 	BIND_ENUM_CONSTANT(AUTOWRAP_OFF);
 	BIND_ENUM_CONSTANT(AUTOWRAP_ARBITRARY);
 	BIND_ENUM_CONSTANT(AUTOWRAP_WORD);
@@ -869,10 +859,11 @@ void Label::_bind_methods() {
 	BIND_ENUM_CONSTANT(OVERRUN_TRIM_WORD_ELLIPSIS);
 
 	ADD_PROPERTY(PropertyInfo(Variant::STRING, "text", PROPERTY_HINT_MULTILINE_TEXT, "", PROPERTY_USAGE_DEFAULT_INTL), "set_text", "get_text");
+	ADD_GROUP("Locale", "");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "text_direction", PROPERTY_HINT_ENUM, "Auto,Left-to-Right,Right-to-Left,Inherited"), "set_text_direction", "get_text_direction");
 	ADD_PROPERTY(PropertyInfo(Variant::STRING, "language"), "set_language", "get_language");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "align", PROPERTY_HINT_ENUM, "Left,Center,Right,Fill"), "set_align", "get_align");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "valign", PROPERTY_HINT_ENUM, "Top,Center,Bottom,Fill"), "set_valign", "get_valign");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "horizontal_alignment", PROPERTY_HINT_ENUM, "Left,Center,Right,Fill"), "set_horizontal_alignment", "get_horizontal_alignment");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "vertical_alignment", PROPERTY_HINT_ENUM, "Top,Center,Bottom,Fill"), "set_vertical_alignment", "get_vertical_alignment");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "autowrap_mode", PROPERTY_HINT_ENUM, "Off,Arbitrary,Word,Word (Smart)"), "set_autowrap_mode", "get_autowrap_mode");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "clip_text"), "set_clip_text", "is_clipping_text");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "text_overrun_behavior", PROPERTY_HINT_ENUM, "Trim Nothing,Trim Characters,Trim Words,Ellipsis,Word Ellipsis"), "set_text_overrun_behavior", "get_text_overrun_behavior");
diff --git a/scene/gui/label.h b/scene/gui/label.h
index 8b48eb9670..2ad8ae8818 100644
--- a/scene/gui/label.h
+++ b/scene/gui/label.h
@@ -37,20 +37,6 @@ class Label : public Control {
 	GDCLASS(Label, Control);
 
 public:
-	enum Align {
-		ALIGN_LEFT,
-		ALIGN_CENTER,
-		ALIGN_RIGHT,
-		ALIGN_FILL
-	};
-
-	enum VAlign {
-		VALIGN_TOP,
-		VALIGN_CENTER,
-		VALIGN_BOTTOM,
-		VALIGN_FILL
-	};
-
 	enum AutowrapMode {
 		AUTOWRAP_OFF,
 		AUTOWRAP_ARBITRARY,
@@ -67,8 +53,8 @@ public:
 	};
 
 private:
-	Align align = ALIGN_LEFT;
-	VAlign valign = VALIGN_TOP;
+	HorizontalAlignment horizontal_alignment = HORIZONTAL_ALIGNMENT_LEFT;
+	VerticalAlignment vertical_alignment = VERTICAL_ALIGNMENT_TOP;
 	String text;
 	String xl_text;
 	AutowrapMode autowrap_mode = AUTOWRAP_OFF;
@@ -109,11 +95,11 @@ protected:
 public:
 	virtual Size2 get_minimum_size() const override;
 
-	void set_align(Align p_align);
-	Align get_align() const;
+	void set_horizontal_alignment(HorizontalAlignment p_alignment);
+	HorizontalAlignment get_horizontal_alignment() const;
 
-	void set_valign(VAlign p_align);
-	VAlign get_valign() const;
+	void set_vertical_alignment(VerticalAlignment p_alignment);
+	VerticalAlignment get_vertical_alignment() const;
 
 	void set_text(const String &p_string);
 	String get_text() const;
@@ -167,8 +153,6 @@ public:
 	~Label();
 };
 
-VARIANT_ENUM_CAST(Label::Align);
-VARIANT_ENUM_CAST(Label::VAlign);
 VARIANT_ENUM_CAST(Label::AutowrapMode);
 VARIANT_ENUM_CAST(Label::OverrunBehavior);
 
diff --git a/scene/gui/line_edit.cpp b/scene/gui/line_edit.cpp
index 80f723de62..9df2f7309c 100644
--- a/scene/gui/line_edit.cpp
+++ b/scene/gui/line_edit.cpp
@@ -548,17 +548,17 @@ void LineEdit::gui_input(const Ref<InputEvent> &p_event) {
 	}
 }
 
-void LineEdit::set_align(Align p_align) {
-	ERR_FAIL_INDEX((int)p_align, 4);
-	if (align != p_align) {
-		align = p_align;
+void LineEdit::set_horizontal_alignment(HorizontalAlignment p_alignment) {
+	ERR_FAIL_INDEX((int)p_alignment, 4);
+	if (alignment != p_alignment) {
+		alignment = p_alignment;
 		_shape();
 	}
 	update();
 }
 
-LineEdit::Align LineEdit::get_align() const {
-	return align;
+HorizontalAlignment LineEdit::get_horizontal_alignment() const {
+	return alignment;
 }
 
 Variant LineEdit::get_drag_data(const Point2 &p_point) {
@@ -715,23 +715,23 @@ void LineEdit::_notification(int p_what) {
 			float text_width = TS->shaped_text_get_size(text_rid).x;
 			float text_height = TS->shaped_text_get_size(text_rid).y + font->get_spacing(TextServer::SPACING_TOP) + font->get_spacing(TextServer::SPACING_BOTTOM);
 
-			switch (align) {
-				case ALIGN_FILL:
-				case ALIGN_LEFT: {
+			switch (alignment) {
+				case HORIZONTAL_ALIGNMENT_FILL:
+				case HORIZONTAL_ALIGNMENT_LEFT: {
 					if (rtl) {
 						x_ofs = MAX(style->get_margin(SIDE_LEFT), int(size.width - style->get_margin(SIDE_RIGHT) - (text_width)));
 					} else {
 						x_ofs = style->get_offset().x;
 					}
 				} break;
-				case ALIGN_CENTER: {
+				case HORIZONTAL_ALIGNMENT_CENTER: {
 					if (scroll_offset != 0) {
 						x_ofs = style->get_offset().x;
 					} else {
 						x_ofs = MAX(style->get_margin(SIDE_LEFT), int(size.width - (text_width)) / 2);
 					}
 				} break;
-				case ALIGN_RIGHT: {
+				case HORIZONTAL_ALIGNMENT_RIGHT: {
 					if (rtl) {
 						x_ofs = style->get_offset().x;
 					} else {
@@ -769,7 +769,7 @@ void LineEdit::_notification(int p_what) {
 
 				r_icon->draw(ci, Point2(width - r_icon->get_width() - style->get_margin(SIDE_RIGHT), height / 2 - r_icon->get_height() / 2), color_icon);
 
-				if (align == ALIGN_CENTER) {
+				if (alignment == HORIZONTAL_ALIGNMENT_CENTER) {
 					if (scroll_offset == 0) {
 						x_ofs = MAX(style->get_margin(SIDE_LEFT), int(size.width - text_width - r_icon->get_width() - style->get_margin(SIDE_RIGHT) * 2) / 2);
 					}
@@ -1115,23 +1115,23 @@ void LineEdit::set_caret_at_pixel_pos(int p_x) {
 
 	int x_ofs = 0;
 	float text_width = TS->shaped_text_get_size(text_rid).x;
-	switch (align) {
-		case ALIGN_FILL:
-		case ALIGN_LEFT: {
+	switch (alignment) {
+		case HORIZONTAL_ALIGNMENT_FILL:
+		case HORIZONTAL_ALIGNMENT_LEFT: {
 			if (rtl) {
 				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - style->get_margin(SIDE_RIGHT) - (text_width)));
 			} else {
 				x_ofs = style->get_offset().x;
 			}
 		} break;
-		case ALIGN_CENTER: {
+		case HORIZONTAL_ALIGNMENT_CENTER: {
 			if (scroll_offset != 0) {
 				x_ofs = style->get_offset().x;
 			} else {
 				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - (text_width)) / 2);
 			}
 		} break;
-		case ALIGN_RIGHT: {
+		case HORIZONTAL_ALIGNMENT_RIGHT: {
 			if (rtl) {
 				x_ofs = style->get_offset().x;
 			} else {
@@ -1144,7 +1144,7 @@ void LineEdit::set_caret_at_pixel_pos(int p_x) {
 	bool display_clear_icon = !using_placeholder && is_editable() && clear_button_enabled;
 	if (right_icon.is_valid() || display_clear_icon) {
 		Ref<Texture2D> r_icon = display_clear_icon ? Control::get_theme_icon(SNAME("clear")) : right_icon;
-		if (align == ALIGN_CENTER) {
+		if (alignment == HORIZONTAL_ALIGNMENT_CENTER) {
 			if (scroll_offset == 0) {
 				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - text_width - r_icon->get_width() - style->get_margin(SIDE_RIGHT) * 2) / 2);
 			}
@@ -1163,23 +1163,23 @@ Vector2i LineEdit::get_caret_pixel_pos() {
 
 	int x_ofs = 0;
 	float text_width = TS->shaped_text_get_size(text_rid).x;
-	switch (align) {
-		case ALIGN_FILL:
-		case ALIGN_LEFT: {
+	switch (alignment) {
+		case HORIZONTAL_ALIGNMENT_FILL:
+		case HORIZONTAL_ALIGNMENT_LEFT: {
 			if (rtl) {
 				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - style->get_margin(SIDE_RIGHT) - (text_width)));
 			} else {
 				x_ofs = style->get_offset().x;
 			}
 		} break;
-		case ALIGN_CENTER: {
+		case HORIZONTAL_ALIGNMENT_CENTER: {
 			if (scroll_offset != 0) {
 				x_ofs = style->get_offset().x;
 			} else {
 				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - (text_width)) / 2);
 			}
 		} break;
-		case ALIGN_RIGHT: {
+		case HORIZONTAL_ALIGNMENT_RIGHT: {
 			if (rtl) {
 				x_ofs = style->get_offset().x;
 			} else {
@@ -1192,7 +1192,7 @@ Vector2i LineEdit::get_caret_pixel_pos() {
 	bool display_clear_icon = !using_placeholder && is_editable() && clear_button_enabled;
 	if (right_icon.is_valid() || display_clear_icon) {
 		Ref<Texture2D> r_icon = display_clear_icon ? Control::get_theme_icon(SNAME("clear")) : right_icon;
-		if (align == ALIGN_CENTER) {
+		if (alignment == HORIZONTAL_ALIGNMENT_CENTER) {
 			if (scroll_offset == 0) {
 				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - text_width - r_icon->get_width() - style->get_margin(SIDE_RIGHT) * 2) / 2);
 			}
@@ -1508,23 +1508,23 @@ void LineEdit::set_caret_column(int p_column) {
 
 	int x_ofs = 0;
 	float text_width = TS->shaped_text_get_size(text_rid).x;
-	switch (align) {
-		case ALIGN_FILL:
-		case ALIGN_LEFT: {
+	switch (alignment) {
+		case HORIZONTAL_ALIGNMENT_FILL:
+		case HORIZONTAL_ALIGNMENT_LEFT: {
 			if (rtl) {
 				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - style->get_margin(SIDE_RIGHT) - (text_width)));
 			} else {
 				x_ofs = style->get_offset().x;
 			}
 		} break;
-		case ALIGN_CENTER: {
+		case HORIZONTAL_ALIGNMENT_CENTER: {
 			if (scroll_offset != 0) {
 				x_ofs = style->get_offset().x;
 			} else {
 				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - (text_width)) / 2);
 			}
 		} break;
-		case ALIGN_RIGHT: {
+		case HORIZONTAL_ALIGNMENT_RIGHT: {
 			if (rtl) {
 				x_ofs = style->get_offset().x;
 			} else {
@@ -1538,7 +1538,7 @@ void LineEdit::set_caret_column(int p_column) {
 	bool display_clear_icon = !using_placeholder && is_editable() && clear_button_enabled;
 	if (right_icon.is_valid() || display_clear_icon) {
 		Ref<Texture2D> r_icon = display_clear_icon ? Control::get_theme_icon(SNAME("clear")) : right_icon;
-		if (align == ALIGN_CENTER) {
+		if (alignment == HORIZONTAL_ALIGNMENT_CENTER) {
 			if (scroll_offset == 0) {
 				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - text_width - r_icon->get_width() - style->get_margin(SIDE_RIGHT) * 2) / 2);
 			}
@@ -2092,7 +2092,7 @@ void LineEdit::_shape() {
 }
 
 void LineEdit::_fit_to_width() {
-	if (align == ALIGN_FILL) {
+	if (alignment == HORIZONTAL_ALIGNMENT_FILL) {
 		Ref<StyleBox> style = get_theme_stylebox(SNAME("normal"));
 		int t_width = get_size().width - style->get_margin(SIDE_RIGHT) - style->get_margin(SIDE_LEFT);
 		bool using_placeholder = text.is_empty() && ime_text.is_empty();
@@ -2218,8 +2218,8 @@ void LineEdit::_validate_property(PropertyInfo &property) const {
 void LineEdit::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("_text_changed"), &LineEdit::_text_changed);
 
-	ClassDB::bind_method(D_METHOD("set_align", "align"), &LineEdit::set_align);
-	ClassDB::bind_method(D_METHOD("get_align"), &LineEdit::get_align);
+	ClassDB::bind_method(D_METHOD("set_horizontal_alignment", "alignment"), &LineEdit::set_horizontal_alignment);
+	ClassDB::bind_method(D_METHOD("get_horizontal_alignment"), &LineEdit::get_horizontal_alignment);
 
 	ClassDB::bind_method(D_METHOD("clear"), &LineEdit::clear);
 	ClassDB::bind_method(D_METHOD("select", "from", "to"), &LineEdit::select, DEFVAL(0), DEFVAL(-1));
@@ -2297,11 +2297,6 @@ void LineEdit::_bind_methods() {
 	ADD_SIGNAL(MethodInfo("text_change_rejected", PropertyInfo(Variant::STRING, "rejected_substring")));
 	ADD_SIGNAL(MethodInfo("text_submitted", PropertyInfo(Variant::STRING, "new_text")));
 
-	BIND_ENUM_CONSTANT(ALIGN_LEFT);
-	BIND_ENUM_CONSTANT(ALIGN_CENTER);
-	BIND_ENUM_CONSTANT(ALIGN_RIGHT);
-	BIND_ENUM_CONSTANT(ALIGN_FILL);
-
 	BIND_ENUM_CONSTANT(MENU_CUT);
 	BIND_ENUM_CONSTANT(MENU_COPY);
 	BIND_ENUM_CONSTANT(MENU_PASTE);
@@ -2333,7 +2328,7 @@ void LineEdit::_bind_methods() {
 	BIND_ENUM_CONSTANT(MENU_MAX);
 
 	ADD_PROPERTY(PropertyInfo(Variant::STRING, "text"), "set_text", "get_text");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "align", PROPERTY_HINT_ENUM, "Left,Center,Right,Fill"), "set_align", "get_align");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "alignment", PROPERTY_HINT_ENUM, "Left,Center,Right,Fill"), "set_horizontal_alignment", "get_horizontal_alignment");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "max_length", PROPERTY_HINT_RANGE, "0,1000,1,or_greater"), "set_max_length", "get_max_length");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "editable"), "set_editable", "is_editable");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "secret"), "set_secret", "is_secret");
diff --git a/scene/gui/line_edit.h b/scene/gui/line_edit.h
index 221dd9eb2e..854e54e8f1 100644
--- a/scene/gui/line_edit.h
+++ b/scene/gui/line_edit.h
@@ -38,13 +38,6 @@ class LineEdit : public Control {
 	GDCLASS(LineEdit, Control);
 
 public:
-	enum Align {
-		ALIGN_LEFT,
-		ALIGN_CENTER,
-		ALIGN_RIGHT,
-		ALIGN_FILL
-	};
-
 	enum MenuItems {
 		MENU_CUT,
 		MENU_COPY,
@@ -78,7 +71,7 @@ public:
 	};
 
 private:
-	Align align = ALIGN_LEFT;
+	HorizontalAlignment alignment = HORIZONTAL_ALIGNMENT_LEFT;
 
 	bool editable = false;
 	bool pass = false;
@@ -218,8 +211,8 @@ protected:
 	void _validate_property(PropertyInfo &property) const override;
 
 public:
-	void set_align(Align p_align);
-	Align get_align() const;
+	void set_horizontal_alignment(HorizontalAlignment p_alignment);
+	HorizontalAlignment get_horizontal_alignment() const;
 
 	virtual Variant get_drag_data(const Point2 &p_point) override;
 	virtual bool can_drop_data(const Point2 &p_point, const Variant &p_data) const override;
@@ -347,7 +340,6 @@ public:
 	~LineEdit();
 };
 
-VARIANT_ENUM_CAST(LineEdit::Align);
 VARIANT_ENUM_CAST(LineEdit::MenuItems);
 
 #endif
diff --git a/scene/gui/option_button.cpp b/scene/gui/option_button.cpp
index dcf3cfeb09..cbbda09261 100644
--- a/scene/gui/option_button.cpp
+++ b/scene/gui/option_button.cpp
@@ -341,7 +341,7 @@ void OptionButton::_bind_methods() {
 
 OptionButton::OptionButton() {
 	set_toggle_mode(true);
-	set_text_align(ALIGN_LEFT);
+	set_text_alignment(HORIZONTAL_ALIGNMENT_LEFT);
 	if (is_layout_rtl()) {
 		if (has_theme_icon(SNAME("arrow"))) {
 			_set_internal_margin(SIDE_LEFT, Control::get_theme_icon(SNAME("arrow"))->get_width());
diff --git a/scene/gui/rich_text_label.cpp b/scene/gui/rich_text_label.cpp
index 2cb6ef91b5..c69565c2f7 100644
--- a/scene/gui/rich_text_label.cpp
+++ b/scene/gui/rich_text_label.cpp
@@ -383,7 +383,7 @@ void RichTextLabel::_shape_line(ItemFrame *p_frame, int p_line, const Ref<Font>
 	// Add indent.
 	l.offset.x = _find_margin(l.from, p_base_font, p_base_font_size);
 	l.text_buf->set_width(p_width - l.offset.x);
-	l.text_buf->set_align((HAlign)_find_align(l.from));
+	l.text_buf->set_alignment(_find_alignment(l.from));
 	l.text_buf->set_direction(_find_direction(l.from));
 
 	if (tab_size > 0) { // Align inline tabs.
@@ -684,13 +684,13 @@ int RichTextLabel::_draw_line(ItemFrame *p_frame, int p_line, const Vector2 &p_o
 			if (!lrtl && p_frame == main) { // Skip Scrollbar.
 				offx -= scroll_w;
 			}
-			font->draw_string(ci, p_ofs + Vector2(p_width - l.offset.x + offx, l.text_buf->get_line_ascent(0)), " " + prefix, HALIGN_LEFT, l.offset.x, font_size, _find_color(l.from, p_base_color));
+			font->draw_string(ci, p_ofs + Vector2(p_width - l.offset.x + offx, l.text_buf->get_line_ascent(0)), " " + prefix, HORIZONTAL_ALIGNMENT_LEFT, l.offset.x, font_size, _find_color(l.from, p_base_color));
 		} else {
 			float offx = 0.0f;
 			if (lrtl && p_frame == main) { // Skip Scrollbar.
 				offx += scroll_w;
 			}
-			font->draw_string(ci, p_ofs + Vector2(offx, l.text_buf->get_line_ascent(0)), prefix + " ", HALIGN_RIGHT, l.offset.x, font_size, _find_color(l.from, p_base_color));
+			font->draw_string(ci, p_ofs + Vector2(offx, l.text_buf->get_line_ascent(0)), prefix + " ", HORIZONTAL_ALIGNMENT_RIGHT, l.offset.x, font_size, _find_color(l.from, p_base_color));
 		}
 	}
 
@@ -734,17 +734,17 @@ int RichTextLabel::_draw_line(ItemFrame *p_frame, int p_line, const Vector2 &p_o
 		}
 
 		// Draw text.
-		switch (l.text_buf->get_align()) {
-			case HALIGN_FILL:
-			case HALIGN_LEFT: {
+		switch (l.text_buf->get_alignment()) {
+			case HORIZONTAL_ALIGNMENT_FILL:
+			case HORIZONTAL_ALIGNMENT_LEFT: {
 				if (rtl) {
 					off.x += width - length;
 				}
 			} break;
-			case HALIGN_CENTER: {
+			case HORIZONTAL_ALIGNMENT_CENTER: {
 				off.x += Math::floor((width - length) / 2.0);
 			} break;
-			case HALIGN_RIGHT: {
+			case HORIZONTAL_ALIGNMENT_RIGHT: {
 				if (!rtl) {
 					off.x += width - length;
 				}
@@ -1214,17 +1214,17 @@ float RichTextLabel::_find_click_in_line(ItemFrame *p_frame, int p_line, const V
 			}
 		}
 
-		switch (l.text_buf->get_align()) {
-			case HALIGN_FILL:
-			case HALIGN_LEFT: {
+		switch (l.text_buf->get_alignment()) {
+			case HORIZONTAL_ALIGNMENT_FILL:
+			case HORIZONTAL_ALIGNMENT_LEFT: {
 				if (rtl) {
 					off.x += width - length;
 				}
 			} break;
-			case HALIGN_CENTER: {
+			case HORIZONTAL_ALIGNMENT_CENTER: {
 				off.x += Math::floor((width - length) / 2.0);
 			} break;
-			case HALIGN_RIGHT: {
+			case HORIZONTAL_ALIGNMENT_RIGHT: {
 				if (!rtl) {
 					off.x += width - length;
 				}
@@ -1950,19 +1950,19 @@ int RichTextLabel::_find_margin(Item *p_item, const Ref<Font> &p_base_font, int
 	return margin;
 }
 
-RichTextLabel::Align RichTextLabel::_find_align(Item *p_item) {
+HorizontalAlignment RichTextLabel::_find_alignment(Item *p_item) {
 	Item *item = p_item;
 
 	while (item) {
 		if (item->type == ITEM_PARAGRAPH) {
 			ItemParagraph *p = static_cast<ItemParagraph *>(item);
-			return p->align;
+			return p->alignment;
 		}
 
 		item = item->parent;
 	}
 
-	return default_align;
+	return default_alignment;
 }
 
 TextServer::Direction RichTextLabel::_find_direction(Item *p_item) {
@@ -2351,7 +2351,7 @@ void RichTextLabel::_remove_item(Item *p_item, const int p_line, const int p_sub
 	}
 }
 
-void RichTextLabel::add_image(const Ref<Texture2D> &p_image, const int p_width, const int p_height, const Color &p_color, InlineAlign p_align) {
+void RichTextLabel::add_image(const Ref<Texture2D> &p_image, const int p_width, const int p_height, const Color &p_color, InlineAlignment p_alignment) {
 	if (current->type == ITEM_TABLE) {
 		return;
 	}
@@ -2363,7 +2363,7 @@ void RichTextLabel::add_image(const Ref<Texture2D> &p_image, const int p_width,
 
 	item->image = p_image;
 	item->color = p_color;
-	item->inline_align = p_align;
+	item->inline_align = p_alignment;
 
 	if (p_width > 0) {
 		// custom width
@@ -2555,11 +2555,11 @@ void RichTextLabel::push_strikethrough() {
 	_add_item(item, true);
 }
 
-void RichTextLabel::push_paragraph(Align p_align, Control::TextDirection p_direction, const String &p_language, Control::StructuredTextParser p_st_parser) {
+void RichTextLabel::push_paragraph(HorizontalAlignment p_alignment, Control::TextDirection p_direction, const String &p_language, Control::StructuredTextParser p_st_parser) {
 	ERR_FAIL_COND(current->type == ITEM_TABLE);
 
 	ItemParagraph *item = memnew(ItemParagraph);
-	item->align = p_align;
+	item->alignment = p_alignment;
 	item->direction = p_direction;
 	item->language = p_language;
 	item->st_parser = p_st_parser;
@@ -2595,13 +2595,13 @@ void RichTextLabel::push_meta(const Variant &p_meta) {
 	_add_item(item, true);
 }
 
-void RichTextLabel::push_table(int p_columns, InlineAlign p_align) {
+void RichTextLabel::push_table(int p_columns, InlineAlignment p_alignment) {
 	ERR_FAIL_COND(p_columns < 1);
 	ItemTable *item = memnew(ItemTable);
 
 	item->columns.resize(p_columns);
 	item->total_width = 0;
-	item->inline_align = p_align;
+	item->inline_align = p_alignment;
 	for (int i = 0; i < item->columns.size(); i++) {
 		item->columns.write[i].expand = false;
 		item->columns.write[i].expand_ratio = 1;
@@ -2958,35 +2958,35 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 				columns = 1;
 			}
 
-			int align = INLINE_ALIGN_TOP;
+			int alignment = INLINE_ALIGNMENT_TOP;
 			if (subtag.size() > 2) {
 				if (subtag[1] == "top" || subtag[1] == "t") {
-					align = INLINE_ALIGN_TOP_TO;
+					alignment = INLINE_ALIGNMENT_TOP_TO;
 				} else if (subtag[1] == "center" || subtag[1] == "c") {
-					align = INLINE_ALIGN_CENTER_TO;
+					alignment = INLINE_ALIGNMENT_CENTER_TO;
 				} else if (subtag[1] == "bottom" || subtag[1] == "b") {
-					align = INLINE_ALIGN_BOTTOM_TO;
+					alignment = INLINE_ALIGNMENT_BOTTOM_TO;
 				}
 				if (subtag[2] == "top" || subtag[2] == "t") {
-					align |= INLINE_ALIGN_TO_TOP;
+					alignment |= INLINE_ALIGNMENT_TO_TOP;
 				} else if (subtag[2] == "center" || subtag[2] == "c") {
-					align |= INLINE_ALIGN_TO_CENTER;
+					alignment |= INLINE_ALIGNMENT_TO_CENTER;
 				} else if (subtag[2] == "baseline" || subtag[2] == "l") {
-					align |= INLINE_ALIGN_TO_BASELINE;
+					alignment |= INLINE_ALIGNMENT_TO_BASELINE;
 				} else if (subtag[2] == "bottom" || subtag[2] == "b") {
-					align |= INLINE_ALIGN_TO_BOTTOM;
+					alignment |= INLINE_ALIGNMENT_TO_BOTTOM;
 				}
 			} else if (subtag.size() > 1) {
 				if (subtag[1] == "top" || subtag[1] == "t") {
-					align = INLINE_ALIGN_TOP;
+					alignment = INLINE_ALIGNMENT_TOP;
 				} else if (subtag[1] == "center" || subtag[1] == "c") {
-					align = INLINE_ALIGN_CENTER;
+					alignment = INLINE_ALIGNMENT_CENTER;
 				} else if (subtag[1] == "bottom" || subtag[1] == "b") {
-					align = INLINE_ALIGN_BOTTOM;
+					alignment = INLINE_ALIGNMENT_BOTTOM;
 				}
 			}
 
-			push_table(columns, (InlineAlign)align);
+			push_table(columns, (InlineAlignment)alignment);
 			pos = brk_end + 1;
 			tag_stack.push_front("table");
 		} else if (tag == "cell") {
@@ -3099,15 +3099,15 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 			add_text(String::chr(0x00AD));
 			pos = brk_end + 1;
 		} else if (tag == "center") {
-			push_paragraph(ALIGN_CENTER);
+			push_paragraph(HORIZONTAL_ALIGNMENT_CENTER);
 			pos = brk_end + 1;
 			tag_stack.push_front(tag);
 		} else if (tag == "fill") {
-			push_paragraph(ALIGN_FILL);
+			push_paragraph(HORIZONTAL_ALIGNMENT_FILL);
 			pos = brk_end + 1;
 			tag_stack.push_front(tag);
 		} else if (tag == "right") {
-			push_paragraph(ALIGN_RIGHT);
+			push_paragraph(HORIZONTAL_ALIGNMENT_RIGHT);
 			pos = brk_end + 1;
 			tag_stack.push_front(tag);
 		} else if (tag == "ul") {
@@ -3146,12 +3146,12 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 			pos = brk_end + 1;
 			tag_stack.push_front(tag);
 		} else if (tag == "p") {
-			push_paragraph(ALIGN_LEFT);
+			push_paragraph(HORIZONTAL_ALIGNMENT_LEFT);
 			pos = brk_end + 1;
 			tag_stack.push_front("p");
 		} else if (tag.begins_with("p ")) {
 			Vector<String> subtag = tag.substr(2, tag.length()).split(" ");
-			Align align = ALIGN_LEFT;
+			HorizontalAlignment alignment = HORIZONTAL_ALIGNMENT_LEFT;
 			Control::TextDirection dir = Control::TEXT_DIRECTION_INHERITED;
 			String lang;
 			Control::StructuredTextParser st_parser = STRUCTURED_TEXT_DEFAULT;
@@ -3160,13 +3160,13 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 				if (subtag_a.size() == 2) {
 					if (subtag_a[0] == "align") {
 						if (subtag_a[1] == "l" || subtag_a[1] == "left") {
-							align = ALIGN_LEFT;
+							alignment = HORIZONTAL_ALIGNMENT_LEFT;
 						} else if (subtag_a[1] == "c" || subtag_a[1] == "center") {
-							align = ALIGN_CENTER;
+							alignment = HORIZONTAL_ALIGNMENT_CENTER;
 						} else if (subtag_a[1] == "r" || subtag_a[1] == "right") {
-							align = ALIGN_RIGHT;
+							alignment = HORIZONTAL_ALIGNMENT_RIGHT;
 						} else if (subtag_a[1] == "f" || subtag_a[1] == "fill") {
-							align = ALIGN_FILL;
+							alignment = HORIZONTAL_ALIGNMENT_FILL;
 						}
 					} else if (subtag_a[0] == "dir" || subtag_a[0] == "direction") {
 						if (subtag_a[1] == "a" || subtag_a[1] == "auto") {
@@ -3197,7 +3197,7 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 					}
 				}
 			}
-			push_paragraph(align, dir, lang, st_parser);
+			push_paragraph(alignment, dir, lang, st_parser);
 			pos = brk_end + 1;
 			tag_stack.push_front("p");
 		} else if (tag == "url") {
@@ -3265,33 +3265,33 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 			pos = end;
 			tag_stack.push_front(bbcode_name);
 		} else if (tag.begins_with("img")) {
-			int align = INLINE_ALIGN_CENTER;
+			int alignment = INLINE_ALIGNMENT_CENTER;
 			if (tag.begins_with("img=")) {
 				Vector<String> subtag = tag.substr(4, tag.length()).split(",");
 				if (subtag.size() > 1) {
 					if (subtag[0] == "top" || subtag[0] == "t") {
-						align = INLINE_ALIGN_TOP_TO;
+						alignment = INLINE_ALIGNMENT_TOP_TO;
 					} else if (subtag[0] == "center" || subtag[0] == "c") {
-						align = INLINE_ALIGN_CENTER_TO;
+						alignment = INLINE_ALIGNMENT_CENTER_TO;
 					} else if (subtag[0] == "bottom" || subtag[0] == "b") {
-						align = INLINE_ALIGN_BOTTOM_TO;
+						alignment = INLINE_ALIGNMENT_BOTTOM_TO;
 					}
 					if (subtag[1] == "top" || subtag[1] == "t") {
-						align |= INLINE_ALIGN_TO_TOP;
+						alignment |= INLINE_ALIGNMENT_TO_TOP;
 					} else if (subtag[1] == "center" || subtag[1] == "c") {
-						align |= INLINE_ALIGN_TO_CENTER;
+						alignment |= INLINE_ALIGNMENT_TO_CENTER;
 					} else if (subtag[1] == "baseline" || subtag[1] == "l") {
-						align |= INLINE_ALIGN_TO_BASELINE;
+						alignment |= INLINE_ALIGNMENT_TO_BASELINE;
 					} else if (subtag[1] == "bottom" || subtag[1] == "b") {
-						align |= INLINE_ALIGN_TO_BOTTOM;
+						alignment |= INLINE_ALIGNMENT_TO_BOTTOM;
 					}
 				} else if (subtag.size() > 0) {
 					if (subtag[0] == "top" || subtag[0] == "t") {
-						align = INLINE_ALIGN_TOP;
+						alignment = INLINE_ALIGNMENT_TOP;
 					} else if (subtag[0] == "center" || subtag[0] == "c") {
-						align = INLINE_ALIGN_CENTER;
+						alignment = INLINE_ALIGNMENT_CENTER;
 					} else if (subtag[0] == "bottom" || subtag[0] == "b") {
-						align = INLINE_ALIGN_BOTTOM;
+						alignment = INLINE_ALIGNMENT_BOTTOM;
 					}
 				}
 			}
@@ -3333,7 +3333,7 @@ void RichTextLabel::append_text(const String &p_bbcode) {
 					}
 				}
 
-				add_image(texture, width, height, color, (InlineAlign)align);
+				add_image(texture, width, height, color, (InlineAlignment)alignment);
 			}
 
 			pos = end;
@@ -4050,7 +4050,7 @@ void RichTextLabel::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_parsed_text"), &RichTextLabel::get_parsed_text);
 	ClassDB::bind_method(D_METHOD("add_text", "text"), &RichTextLabel::add_text);
 	ClassDB::bind_method(D_METHOD("set_text", "text"), &RichTextLabel::set_text);
-	ClassDB::bind_method(D_METHOD("add_image", "image", "width", "height", "color", "inline_align"), &RichTextLabel::add_image, DEFVAL(0), DEFVAL(0), DEFVAL(Color(1.0, 1.0, 1.0)), DEFVAL(INLINE_ALIGN_CENTER));
+	ClassDB::bind_method(D_METHOD("add_image", "image", "width", "height", "color", "inline_align"), &RichTextLabel::add_image, DEFVAL(0), DEFVAL(0), DEFVAL(Color(1.0, 1.0, 1.0)), DEFVAL(INLINE_ALIGNMENT_CENTER));
 	ClassDB::bind_method(D_METHOD("newline"), &RichTextLabel::add_newline);
 	ClassDB::bind_method(D_METHOD("remove_line", "line"), &RichTextLabel::remove_line);
 	ClassDB::bind_method(D_METHOD("push_font", "font"), &RichTextLabel::push_font);
@@ -4064,13 +4064,13 @@ void RichTextLabel::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("push_color", "color"), &RichTextLabel::push_color);
 	ClassDB::bind_method(D_METHOD("push_outline_size", "outline_size"), &RichTextLabel::push_outline_size);
 	ClassDB::bind_method(D_METHOD("push_outline_color", "color"), &RichTextLabel::push_outline_color);
-	ClassDB::bind_method(D_METHOD("push_paragraph", "align", "base_direction", "language", "st_parser"), &RichTextLabel::push_paragraph, DEFVAL(TextServer::DIRECTION_AUTO), DEFVAL(""), DEFVAL(STRUCTURED_TEXT_DEFAULT));
+	ClassDB::bind_method(D_METHOD("push_paragraph", "alignment", "base_direction", "language", "st_parser"), &RichTextLabel::push_paragraph, DEFVAL(TextServer::DIRECTION_AUTO), DEFVAL(""), DEFVAL(STRUCTURED_TEXT_DEFAULT));
 	ClassDB::bind_method(D_METHOD("push_indent", "level"), &RichTextLabel::push_indent);
 	ClassDB::bind_method(D_METHOD("push_list", "level", "type", "capitalize"), &RichTextLabel::push_list);
 	ClassDB::bind_method(D_METHOD("push_meta", "data"), &RichTextLabel::push_meta);
 	ClassDB::bind_method(D_METHOD("push_underline"), &RichTextLabel::push_underline);
 	ClassDB::bind_method(D_METHOD("push_strikethrough"), &RichTextLabel::push_strikethrough);
-	ClassDB::bind_method(D_METHOD("push_table", "columns", "inline_align"), &RichTextLabel::push_table, DEFVAL(INLINE_ALIGN_TOP));
+	ClassDB::bind_method(D_METHOD("push_table", "columns", "inline_align"), &RichTextLabel::push_table, DEFVAL(INLINE_ALIGNMENT_TOP));
 	ClassDB::bind_method(D_METHOD("push_dropcap", "string", "font", "size", "dropcap_margins", "color", "outline_size", "outline_color"), &RichTextLabel::push_dropcap, DEFVAL(Rect2()), DEFVAL(Color(1, 1, 1)), DEFVAL(0), DEFVAL(Color(0, 0, 0, 0)));
 	ClassDB::bind_method(D_METHOD("set_table_column_expand", "column", "expand", "ratio"), &RichTextLabel::set_table_column_expand);
 	ClassDB::bind_method(D_METHOD("set_cell_row_background_color", "odd_row_bg", "even_row_bg"), &RichTextLabel::set_cell_row_background_color);
@@ -4188,11 +4188,6 @@ void RichTextLabel::_bind_methods() {
 	ADD_SIGNAL(MethodInfo("meta_hover_started", PropertyInfo(Variant::NIL, "meta", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NIL_IS_VARIANT)));
 	ADD_SIGNAL(MethodInfo("meta_hover_ended", PropertyInfo(Variant::NIL, "meta", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NIL_IS_VARIANT)));
 
-	BIND_ENUM_CONSTANT(ALIGN_LEFT);
-	BIND_ENUM_CONSTANT(ALIGN_CENTER);
-	BIND_ENUM_CONSTANT(ALIGN_RIGHT);
-	BIND_ENUM_CONSTANT(ALIGN_FILL);
-
 	BIND_ENUM_CONSTANT(LIST_NUMBERS);
 	BIND_ENUM_CONSTANT(LIST_LETTERS);
 	BIND_ENUM_CONSTANT(LIST_ROMAN);
diff --git a/scene/gui/rich_text_label.h b/scene/gui/rich_text_label.h
index 5b58f14d96..58a531e5ad 100644
--- a/scene/gui/rich_text_label.h
+++ b/scene/gui/rich_text_label.h
@@ -39,13 +39,6 @@ class RichTextLabel : public Control {
 	GDCLASS(RichTextLabel, Control);
 
 public:
-	enum Align {
-		ALIGN_LEFT,
-		ALIGN_CENTER,
-		ALIGN_RIGHT,
-		ALIGN_FILL
-	};
-
 	enum ListType {
 		LIST_NUMBERS,
 		LIST_LETTERS,
@@ -160,7 +153,7 @@ private:
 
 	struct ItemImage : public Item {
 		Ref<Texture2D> image;
-		InlineAlign inline_align = INLINE_ALIGN_CENTER;
+		InlineAlignment inline_align = INLINE_ALIGNMENT_CENTER;
 		Size2 size;
 		Color color;
 		ItemImage() { type = ITEM_IMAGE; }
@@ -210,7 +203,7 @@ private:
 	};
 
 	struct ItemParagraph : public Item {
-		Align align = ALIGN_LEFT;
+		HorizontalAlignment alignment = HORIZONTAL_ALIGNMENT_LEFT;
 		String language;
 		Control::TextDirection direction = Control::TEXT_DIRECTION_AUTO;
 		Control::StructuredTextParser st_parser = STRUCTURED_TEXT_DEFAULT;
@@ -247,7 +240,7 @@ private:
 
 		int total_width = 0;
 		int total_height = 0;
-		InlineAlign inline_align = INLINE_ALIGN_TOP;
+		InlineAlignment inline_align = INLINE_ALIGNMENT_TOP;
 		ItemTable() { type = ITEM_TABLE; }
 	};
 
@@ -360,7 +353,7 @@ private:
 	bool underline_meta = true;
 	bool override_selected_font_color = false;
 
-	Align default_align = ALIGN_LEFT;
+	HorizontalAlignment default_alignment = HORIZONTAL_ALIGNMENT_LEFT;
 
 	ItemMeta *meta_hovering = nullptr;
 	Variant current_meta;
@@ -428,7 +421,7 @@ private:
 	ItemDropcap *_find_dc_item(Item *p_item);
 	int _find_list(Item *p_item, Vector<int> &r_index, Vector<ItemList *> &r_list);
 	int _find_margin(Item *p_item, const Ref<Font> &p_base_font, int p_base_font_size);
-	Align _find_align(Item *p_item);
+	HorizontalAlignment _find_alignment(Item *p_item);
 	TextServer::Direction _find_direction(Item *p_item);
 	Control::StructuredTextParser _find_stt(Item *p_item);
 	String _find_language(Item *p_item);
@@ -469,7 +462,7 @@ private:
 public:
 	String get_parsed_text() const;
 	void add_text(const String &p_text);
-	void add_image(const Ref<Texture2D> &p_image, const int p_width = 0, const int p_height = 0, const Color &p_color = Color(1.0, 1.0, 1.0), InlineAlign p_align = INLINE_ALIGN_CENTER);
+	void add_image(const Ref<Texture2D> &p_image, const int p_width = 0, const int p_height = 0, const Color &p_color = Color(1.0, 1.0, 1.0), InlineAlignment p_alignment = INLINE_ALIGNMENT_CENTER);
 	void add_newline();
 	bool remove_line(const int p_line);
 	void push_dropcap(const String &p_string, const Ref<Font> &p_font, int p_size, const Rect2 &p_dropcap_margins = Rect2(), const Color &p_color = Color(1, 1, 1), int p_ol_size = 0, const Color &p_ol_color = Color(0, 0, 0, 0));
@@ -486,11 +479,11 @@ public:
 	void push_outline_color(const Color &p_color);
 	void push_underline();
 	void push_strikethrough();
-	void push_paragraph(Align p_align, Control::TextDirection p_direction = Control::TEXT_DIRECTION_INHERITED, const String &p_language = "", Control::StructuredTextParser p_st_parser = STRUCTURED_TEXT_DEFAULT);
+	void push_paragraph(HorizontalAlignment p_alignment, Control::TextDirection p_direction = Control::TEXT_DIRECTION_INHERITED, const String &p_language = "", Control::StructuredTextParser p_st_parser = STRUCTURED_TEXT_DEFAULT);
 	void push_indent(int p_level);
 	void push_list(int p_level, ListType p_list, bool p_capitalize);
 	void push_meta(const Variant &p_meta);
-	void push_table(int p_columns, InlineAlign p_align = INLINE_ALIGN_TOP);
+	void push_table(int p_columns, InlineAlignment p_alignment = INLINE_ALIGNMENT_TOP);
 	void push_fade(int p_start_index, int p_length);
 	void push_shake(int p_strength, float p_rate);
 	void push_wave(float p_frequency, float p_amplitude);
@@ -595,7 +588,6 @@ public:
 	~RichTextLabel();
 };
 
-VARIANT_ENUM_CAST(RichTextLabel::Align);
 VARIANT_ENUM_CAST(RichTextLabel::ListType);
 VARIANT_ENUM_CAST(RichTextLabel::ItemType);
 
diff --git a/scene/gui/spin_box.cpp b/scene/gui/spin_box.cpp
index 94a4886fef..c4a1d8e5a6 100644
--- a/scene/gui/spin_box.cpp
+++ b/scene/gui/spin_box.cpp
@@ -227,12 +227,12 @@ void SpinBox::_notification(int p_what) {
 	}
 }
 
-void SpinBox::set_align(LineEdit::Align p_align) {
-	line_edit->set_align(p_align);
+void SpinBox::set_horizontal_alignment(HorizontalAlignment p_alignment) {
+	line_edit->set_horizontal_alignment(p_alignment);
 }
 
-LineEdit::Align SpinBox::get_align() const {
-	return line_edit->get_align();
+HorizontalAlignment SpinBox::get_horizontal_alignment() const {
+	return line_edit->get_horizontal_alignment();
 }
 
 void SpinBox::set_suffix(const String &p_suffix) {
@@ -284,8 +284,8 @@ void SpinBox::apply() {
 }
 
 void SpinBox::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_align", "align"), &SpinBox::set_align);
-	ClassDB::bind_method(D_METHOD("get_align"), &SpinBox::get_align);
+	ClassDB::bind_method(D_METHOD("set_horizontal_alignment", "alignment"), &SpinBox::set_horizontal_alignment);
+	ClassDB::bind_method(D_METHOD("get_horizontal_alignment"), &SpinBox::get_horizontal_alignment);
 	ClassDB::bind_method(D_METHOD("set_suffix", "suffix"), &SpinBox::set_suffix);
 	ClassDB::bind_method(D_METHOD("get_suffix"), &SpinBox::get_suffix);
 	ClassDB::bind_method(D_METHOD("set_prefix", "prefix"), &SpinBox::set_prefix);
@@ -297,7 +297,7 @@ void SpinBox::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("apply"), &SpinBox::apply);
 	ClassDB::bind_method(D_METHOD("get_line_edit"), &SpinBox::get_line_edit);
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "align", PROPERTY_HINT_ENUM, "Left,Center,Right,Fill"), "set_align", "get_align");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "alignment", PROPERTY_HINT_ENUM, "Left,Center,Right,Fill"), "set_horizontal_alignment", "get_horizontal_alignment");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "editable"), "set_editable", "is_editable");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "update_on_text_changed"), "set_update_on_text_changed", "get_update_on_text_changed");
 	ADD_PROPERTY(PropertyInfo(Variant::STRING, "prefix"), "set_prefix", "get_prefix");
@@ -310,7 +310,7 @@ SpinBox::SpinBox() {
 
 	line_edit->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
 	line_edit->set_mouse_filter(MOUSE_FILTER_PASS);
-	line_edit->set_align(LineEdit::ALIGN_LEFT);
+	line_edit->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_LEFT);
 
 	line_edit->connect("text_submitted", callable_mp(this, &SpinBox::_text_submitted), Vector<Variant>(), CONNECT_DEFERRED);
 	line_edit->connect("focus_exited", callable_mp(this, &SpinBox::_line_edit_focus_exit), Vector<Variant>(), CONNECT_DEFERRED);
diff --git a/scene/gui/spin_box.h b/scene/gui/spin_box.h
index f2299ce1c2..736a5d873d 100644
--- a/scene/gui/spin_box.h
+++ b/scene/gui/spin_box.h
@@ -79,8 +79,8 @@ public:
 
 	virtual Size2 get_minimum_size() const override;
 
-	void set_align(LineEdit::Align p_align);
-	LineEdit::Align get_align() const;
+	void set_horizontal_alignment(HorizontalAlignment p_alignment);
+	HorizontalAlignment get_horizontal_alignment() const;
 
 	void set_editable(bool p_enabled);
 	bool is_editable() const;
diff --git a/scene/gui/tab_bar.cpp b/scene/gui/tab_bar.cpp
index da23b0dde8..dd410e2472 100644
--- a/scene/gui/tab_bar.cpp
+++ b/scene/gui/tab_bar.cpp
@@ -319,9 +319,9 @@ void TabBar::_notification(int p_what) {
 				mw += get_tab_width(i);
 			}
 
-			if (tab_align == ALIGN_CENTER) {
+			if (tab_alignment == ALIGNMENT_CENTER) {
 				w = (get_size().width - mw) / 2;
-			} else if (tab_align == ALIGN_RIGHT) {
+			} else if (tab_alignment == ALIGNMENT_RIGHT) {
 				w = get_size().width - mw;
 			}
 
@@ -929,14 +929,14 @@ int TabBar::get_tab_idx_at_point(const Point2 &p_point) const {
 	return hover_now;
 }
 
-void TabBar::set_tab_align(TabAlign p_align) {
-	ERR_FAIL_INDEX(p_align, ALIGN_MAX);
-	tab_align = p_align;
+void TabBar::set_tab_alignment(AlignmentMode p_alignment) {
+	ERR_FAIL_INDEX(p_alignment, ALIGNMENT_MAX);
+	tab_alignment = p_alignment;
 	update();
 }
 
-TabBar::TabAlign TabBar::get_tab_align() const {
-	return tab_align;
+TabBar::AlignmentMode TabBar::get_tab_alignment() const {
+	return tab_alignment;
 }
 
 void TabBar::set_clip_tabs(bool p_clip_tabs) {
@@ -1149,8 +1149,8 @@ void TabBar::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_tab_disabled", "tab_idx"), &TabBar::get_tab_disabled);
 	ClassDB::bind_method(D_METHOD("remove_tab", "tab_idx"), &TabBar::remove_tab);
 	ClassDB::bind_method(D_METHOD("add_tab", "title", "icon"), &TabBar::add_tab, DEFVAL(""), DEFVAL(Ref<Texture2D>()));
-	ClassDB::bind_method(D_METHOD("set_tab_align", "align"), &TabBar::set_tab_align);
-	ClassDB::bind_method(D_METHOD("get_tab_align"), &TabBar::get_tab_align);
+	ClassDB::bind_method(D_METHOD("set_tab_alignment", "alignment"), &TabBar::set_tab_alignment);
+	ClassDB::bind_method(D_METHOD("get_tab_alignment"), &TabBar::get_tab_alignment);
 	ClassDB::bind_method(D_METHOD("set_clip_tabs", "clip_tabs"), &TabBar::set_clip_tabs);
 	ClassDB::bind_method(D_METHOD("get_clip_tabs"), &TabBar::get_clip_tabs);
 	ClassDB::bind_method(D_METHOD("get_tab_offset"), &TabBar::get_tab_offset);
@@ -1178,16 +1178,16 @@ void TabBar::_bind_methods() {
 	ADD_SIGNAL(MethodInfo("tab_clicked", PropertyInfo(Variant::INT, "tab")));
 
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "current_tab", PROPERTY_HINT_RANGE, "-1,4096,1", PROPERTY_USAGE_EDITOR), "set_current_tab", "get_current_tab");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "tab_align", PROPERTY_HINT_ENUM, "Left,Center,Right"), "set_tab_align", "get_tab_align");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "tab_alignment", PROPERTY_HINT_ENUM, "Left,Center,Right"), "set_tab_alignment", "get_tab_alignment");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "clip_tabs"), "set_clip_tabs", "get_clip_tabs");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "tab_close_display_policy", PROPERTY_HINT_ENUM, "Show Never,Show Active Only,Show Always"), "set_tab_close_display_policy", "get_tab_close_display_policy");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "scrolling_enabled"), "set_scrolling_enabled", "get_scrolling_enabled");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "drag_to_rearrange_enabled"), "set_drag_to_rearrange_enabled", "get_drag_to_rearrange_enabled");
 
-	BIND_ENUM_CONSTANT(ALIGN_LEFT);
-	BIND_ENUM_CONSTANT(ALIGN_CENTER);
-	BIND_ENUM_CONSTANT(ALIGN_RIGHT);
-	BIND_ENUM_CONSTANT(ALIGN_MAX);
+	BIND_ENUM_CONSTANT(ALIGNMENT_LEFT);
+	BIND_ENUM_CONSTANT(ALIGNMENT_CENTER);
+	BIND_ENUM_CONSTANT(ALIGNMENT_RIGHT);
+	BIND_ENUM_CONSTANT(ALIGNMENT_MAX);
 
 	BIND_ENUM_CONSTANT(CLOSE_BUTTON_SHOW_NEVER);
 	BIND_ENUM_CONSTANT(CLOSE_BUTTON_SHOW_ACTIVE_ONLY);
diff --git a/scene/gui/tab_bar.h b/scene/gui/tab_bar.h
index 411a62b1d9..2d211937fc 100644
--- a/scene/gui/tab_bar.h
+++ b/scene/gui/tab_bar.h
@@ -38,11 +38,11 @@ class TabBar : public Control {
 	GDCLASS(TabBar, Control);
 
 public:
-	enum TabAlign {
-		ALIGN_LEFT,
-		ALIGN_CENTER,
-		ALIGN_RIGHT,
-		ALIGN_MAX
+	enum AlignmentMode {
+		ALIGNMENT_LEFT,
+		ALIGNMENT_CENTER,
+		ALIGNMENT_RIGHT,
+		ALIGNMENT_MAX,
 	};
 
 	enum CloseButtonDisplayPolicy {
@@ -83,7 +83,7 @@ private:
 	Vector<Tab> tabs;
 	int current = 0;
 	int previous = 0;
-	TabAlign tab_align = ALIGN_CENTER;
+	AlignmentMode tab_alignment = ALIGNMENT_CENTER;
 	bool clip_tabs = true;
 	int rb_hover = -1;
 	bool rb_pressing = false;
@@ -145,8 +145,8 @@ public:
 	void set_tab_right_button(int p_tab, const Ref<Texture2D> &p_right_button);
 	Ref<Texture2D> get_tab_right_button(int p_tab) const;
 
-	void set_tab_align(TabAlign p_align);
-	TabAlign get_tab_align() const;
+	void set_tab_alignment(AlignmentMode p_alignment);
+	AlignmentMode get_tab_alignment() const;
 
 	void set_clip_tabs(bool p_clip_tabs);
 	bool get_clip_tabs() const;
@@ -189,7 +189,7 @@ public:
 	TabBar();
 };
 
-VARIANT_ENUM_CAST(TabBar::TabAlign);
+VARIANT_ENUM_CAST(TabBar::AlignmentMode);
 VARIANT_ENUM_CAST(TabBar::CloseButtonDisplayPolicy);
 
 #endif // TAB_BAR_H
diff --git a/scene/gui/tab_container.cpp b/scene/gui/tab_container.cpp
index 562f523f53..23e8f2bce8 100644
--- a/scene/gui/tab_container.cpp
+++ b/scene/gui/tab_container.cpp
@@ -406,14 +406,14 @@ void TabContainer::_notification(int p_what) {
 			}
 
 			// Find the offset at which to draw tabs, according to the alignment.
-			switch (align) {
-				case ALIGN_LEFT:
+			switch (alignment) {
+				case ALIGNMENT_LEFT:
 					tabs_ofs_cache = header_x;
 					break;
-				case ALIGN_CENTER:
+				case ALIGNMENT_CENTER:
 					tabs_ofs_cache = header_x + (header_width / 2) - (all_tabs_width / 2);
 					break;
-				case ALIGN_RIGHT:
+				case ALIGNMENT_RIGHT:
 					tabs_ofs_cache = header_x + header_width - all_tabs_width;
 					break;
 			}
@@ -967,14 +967,14 @@ int TabContainer::get_tab_idx_at_point(const Point2 &p_point) const {
 	return -1;
 }
 
-void TabContainer::set_tab_align(TabAlign p_align) {
-	ERR_FAIL_INDEX(p_align, 3);
-	align = p_align;
+void TabContainer::set_tab_alignment(AlignmentMode p_alignment) {
+	ERR_FAIL_INDEX(p_alignment, 3);
+	alignment = p_alignment;
 	update();
 }
 
-TabContainer::TabAlign TabContainer::get_tab_align() const {
-	return align;
+TabContainer::AlignmentMode TabContainer::get_tab_alignment() const {
+	return alignment;
 }
 
 void TabContainer::set_tabs_visible(bool p_visible) {
@@ -1198,8 +1198,8 @@ void TabContainer::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_previous_tab"), &TabContainer::get_previous_tab);
 	ClassDB::bind_method(D_METHOD("get_current_tab_control"), &TabContainer::get_current_tab_control);
 	ClassDB::bind_method(D_METHOD("get_tab_control", "tab_idx"), &TabContainer::get_tab_control);
-	ClassDB::bind_method(D_METHOD("set_tab_align", "align"), &TabContainer::set_tab_align);
-	ClassDB::bind_method(D_METHOD("get_tab_align"), &TabContainer::get_tab_align);
+	ClassDB::bind_method(D_METHOD("set_tab_alignment", "alignment"), &TabContainer::set_tab_alignment);
+	ClassDB::bind_method(D_METHOD("get_tab_alignment"), &TabContainer::get_tab_alignment);
 	ClassDB::bind_method(D_METHOD("set_tabs_visible", "visible"), &TabContainer::set_tabs_visible);
 	ClassDB::bind_method(D_METHOD("are_tabs_visible"), &TabContainer::are_tabs_visible);
 	ClassDB::bind_method(D_METHOD("set_all_tabs_in_front", "is_front"), &TabContainer::set_all_tabs_in_front);
@@ -1230,16 +1230,16 @@ void TabContainer::_bind_methods() {
 	ADD_SIGNAL(MethodInfo("tab_selected", PropertyInfo(Variant::INT, "tab")));
 	ADD_SIGNAL(MethodInfo("pre_popup_pressed"));
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "tab_align", PROPERTY_HINT_ENUM, "Left,Center,Right"), "set_tab_align", "get_tab_align");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "tab_alignment", PROPERTY_HINT_ENUM, "Left,Center,Right"), "set_tab_alignment", "get_tab_alignment");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "current_tab", PROPERTY_HINT_RANGE, "-1,4096,1", PROPERTY_USAGE_EDITOR), "set_current_tab", "get_current_tab");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "tabs_visible"), "set_tabs_visible", "are_tabs_visible");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "all_tabs_in_front"), "set_all_tabs_in_front", "is_all_tabs_in_front");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "drag_to_rearrange_enabled"), "set_drag_to_rearrange_enabled", "get_drag_to_rearrange_enabled");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_hidden_tabs_for_min_size"), "set_use_hidden_tabs_for_min_size", "get_use_hidden_tabs_for_min_size");
 
-	BIND_ENUM_CONSTANT(ALIGN_LEFT);
-	BIND_ENUM_CONSTANT(ALIGN_CENTER);
-	BIND_ENUM_CONSTANT(ALIGN_RIGHT);
+	BIND_ENUM_CONSTANT(ALIGNMENT_LEFT);
+	BIND_ENUM_CONSTANT(ALIGNMENT_CENTER);
+	BIND_ENUM_CONSTANT(ALIGNMENT_RIGHT);
 }
 
 TabContainer::TabContainer() {
diff --git a/scene/gui/tab_container.h b/scene/gui/tab_container.h
index fe96df25e8..6dfeb2b625 100644
--- a/scene/gui/tab_container.h
+++ b/scene/gui/tab_container.h
@@ -39,10 +39,10 @@ class TabContainer : public Container {
 	GDCLASS(TabContainer, Container);
 
 public:
-	enum TabAlign {
-		ALIGN_LEFT,
-		ALIGN_CENTER,
-		ALIGN_RIGHT
+	enum AlignmentMode {
+		ALIGNMENT_LEFT,
+		ALIGNMENT_CENTER,
+		ALIGNMENT_RIGHT,
 	};
 
 private:
@@ -56,7 +56,7 @@ private:
 	bool buttons_visible_cache = false;
 	bool menu_hovered = false;
 	int highlight_arrow = -1;
-	TabAlign align = ALIGN_CENTER;
+	AlignmentMode alignment = ALIGNMENT_CENTER;
 	int _get_top_margin() const;
 	mutable ObjectID popup_obj_id;
 	bool drag_to_rearrange_enabled = false;
@@ -90,8 +90,8 @@ protected:
 	static void _bind_methods();
 
 public:
-	void set_tab_align(TabAlign p_align);
-	TabAlign get_tab_align() const;
+	void set_tab_alignment(AlignmentMode p_alignment);
+	AlignmentMode get_tab_alignment() const;
 
 	void set_tabs_visible(bool p_visible);
 	bool are_tabs_visible() const;
@@ -136,6 +136,6 @@ public:
 	TabContainer();
 };
 
-VARIANT_ENUM_CAST(TabContainer::TabAlign);
+VARIANT_ENUM_CAST(TabContainer::AlignmentMode);
 
 #endif // TAB_CONTAINER_H
diff --git a/scene/gui/tree.cpp b/scene/gui/tree.cpp
index 050ba9f519..d2d4167a25 100644
--- a/scene/gui/tree.cpp
+++ b/scene/gui/tree.cpp
@@ -1002,18 +1002,18 @@ bool TreeItem::is_custom_set_as_button(int p_column) const {
 	return cells[p_column].custom_button;
 }
 
-void TreeItem::set_text_align(int p_column, TextAlign p_align) {
+void TreeItem::set_text_alignment(int p_column, HorizontalAlignment p_alignment) {
 	ERR_FAIL_INDEX(p_column, cells.size());
 
-	cells.write[p_column].text_align = p_align;
+	cells.write[p_column].text_alignment = p_alignment;
 	cells.write[p_column].cached_minimum_size_dirty = true;
 
 	_changed_notify(p_column);
 }
 
-TreeItem::TextAlign TreeItem::get_text_align(int p_column) const {
-	ERR_FAIL_INDEX_V(p_column, cells.size(), ALIGN_LEFT);
-	return cells[p_column].text_align;
+HorizontalAlignment TreeItem::get_text_alignment(int p_column) const {
+	ERR_FAIL_INDEX_V(p_column, cells.size(), HORIZONTAL_ALIGNMENT_LEFT);
+	return cells[p_column].text_alignment;
 }
 
 void TreeItem::set_expand_right(int p_column, bool p_enable) {
@@ -1231,8 +1231,8 @@ void TreeItem::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("set_tooltip", "column", "tooltip"), &TreeItem::set_tooltip);
 	ClassDB::bind_method(D_METHOD("get_tooltip", "column"), &TreeItem::get_tooltip);
-	ClassDB::bind_method(D_METHOD("set_text_align", "column", "text_align"), &TreeItem::set_text_align);
-	ClassDB::bind_method(D_METHOD("get_text_align", "column"), &TreeItem::get_text_align);
+	ClassDB::bind_method(D_METHOD("set_text_alignment", "column", "text_alignment"), &TreeItem::set_text_alignment);
+	ClassDB::bind_method(D_METHOD("get_text_alignment", "column"), &TreeItem::get_text_alignment);
 
 	ClassDB::bind_method(D_METHOD("set_expand_right", "column", "enable"), &TreeItem::set_expand_right);
 	ClassDB::bind_method(D_METHOD("get_expand_right", "column"), &TreeItem::get_expand_right);
@@ -1278,10 +1278,6 @@ void TreeItem::_bind_methods() {
 	BIND_ENUM_CONSTANT(CELL_MODE_RANGE);
 	BIND_ENUM_CONSTANT(CELL_MODE_ICON);
 	BIND_ENUM_CONSTANT(CELL_MODE_CUSTOM);
-
-	BIND_ENUM_CONSTANT(ALIGN_LEFT);
-	BIND_ENUM_CONSTANT(ALIGN_CENTER);
-	BIND_ENUM_CONSTANT(ALIGN_RIGHT);
 }
 
 void TreeItem::clear_children() {
@@ -1477,16 +1473,17 @@ void Tree::draw_item_rect(TreeItem::Cell &p_cell, const Rect2i &p_rect, const Co
 	}
 	w += ts.width;
 
-	switch (p_cell.text_align) {
-		case TreeItem::ALIGN_LEFT:
+	switch (p_cell.text_alignment) {
+		case HORIZONTAL_ALIGNMENT_FILL:
+		case HORIZONTAL_ALIGNMENT_LEFT: {
 			if (rtl) {
 				rect.position.x += MAX(0, (rect.size.width - w));
 			}
-			break;
-		case TreeItem::ALIGN_CENTER:
+		} break;
+		case HORIZONTAL_ALIGNMENT_CENTER:
 			rect.position.x += MAX(0, (rect.size.width - w) / 2);
 			break;
-		case TreeItem::ALIGN_RIGHT:
+		case HORIZONTAL_ALIGNMENT_RIGHT:
 			if (!rtl) {
 				rect.position.x += MAX(0, (rect.size.width - w));
 			}
diff --git a/scene/gui/tree.h b/scene/gui/tree.h
index d4caec614a..a190567f0f 100644
--- a/scene/gui/tree.h
+++ b/scene/gui/tree.h
@@ -52,12 +52,6 @@ public:
 		CELL_MODE_CUSTOM, ///< Contains a custom value, show a string, and an edit button
 	};
 
-	enum TextAlign {
-		ALIGN_LEFT,
-		ALIGN_CENTER,
-		ALIGN_RIGHT
-	};
-
 private:
 	friend class Tree;
 
@@ -98,7 +92,7 @@ private:
 		Size2i cached_minimum_size;
 		bool cached_minimum_size_dirty = true;
 
-		TextAlign text_align = ALIGN_LEFT;
+		HorizontalAlignment text_alignment = HORIZONTAL_ALIGNMENT_LEFT;
 
 		Variant meta;
 		String tooltip;
@@ -316,8 +310,8 @@ public:
 	void set_tooltip(int p_column, const String &p_tooltip);
 	String get_tooltip(int p_column) const;
 
-	void set_text_align(int p_column, TextAlign p_align);
-	TextAlign get_text_align(int p_column) const;
+	void set_text_alignment(int p_column, HorizontalAlignment p_alignment);
+	HorizontalAlignment get_text_alignment(int p_column) const;
 
 	void set_expand_right(int p_column, bool p_enable);
 	bool get_expand_right(int p_column) const;
@@ -359,7 +353,6 @@ public:
 };
 
 VARIANT_ENUM_CAST(TreeItem::TreeCellMode);
-VARIANT_ENUM_CAST(TreeItem::TextAlign);
 
 class VBoxContainer;