Rename Control margin to offset

28 files changed, 428 insertions, 428 deletions

diff --git a/scene/gui/button.cpp b/scene/gui/button.cpp
index 711e5f9262..0cdfa9457e 100644
--- a/scene/gui/button.cpp
+++ b/scene/gui/button.cpp
@@ -59,8 +59,8 @@ Size2 Button::get_minimum_size() const {
 	return get_theme_stylebox("normal")->get_minimum_size() + minsize;
 }
 
-void Button::_set_internal_margin(Margin p_margin, float p_value) {
-	_internal_margin[p_margin] = p_value;
+void Button::_set_internal_margin(Side p_side, float p_value) {
+	_internal_margin[p_side] = p_value;
 }
 
 void Button::_notification(int p_what) {
@@ -205,12 +205,12 @@ void Button::_notification(int p_what) {
 
 				float icon_ofs_region = 0;
 				if (rtl) {
-					if (_internal_margin[MARGIN_RIGHT] > 0) {
-						icon_ofs_region = _internal_margin[MARGIN_RIGHT] + get_theme_constant("hseparation");
+					if (_internal_margin[SIDE_RIGHT] > 0) {
+						icon_ofs_region = _internal_margin[SIDE_RIGHT] + get_theme_constant("hseparation");
 					}
 				} else {
-					if (_internal_margin[MARGIN_LEFT] > 0) {
-						icon_ofs_region = _internal_margin[MARGIN_LEFT] + get_theme_constant("hseparation");
+					if (_internal_margin[SIDE_LEFT] > 0) {
+						icon_ofs_region = _internal_margin[SIDE_LEFT] + get_theme_constant("hseparation");
 					}
 				}
 
@@ -229,13 +229,13 @@ void Button::_notification(int p_what) {
 					}
 
 					if (rtl) {
-						icon_region = Rect2(Point2(size.width - (icon_ofs_region + icon_width + style->get_margin(MARGIN_RIGHT)), style->get_margin(MARGIN_TOP) + (_size.height - icon_height) / 2), Size2(icon_width, icon_height));
+						icon_region = Rect2(Point2(size.width - (icon_ofs_region + icon_width + style->get_margin(SIDE_RIGHT)), style->get_margin(SIDE_TOP) + (_size.height - icon_height) / 2), Size2(icon_width, icon_height));
 					} else {
 						icon_region = Rect2(style->get_offset() + Point2(icon_ofs_region, (_size.height - icon_height) / 2), Size2(icon_width, icon_height));
 					}
 				} else {
 					if (rtl) {
-						icon_region = Rect2(Point2(size.width - (icon_ofs_region + _icon->get_size().width + style->get_margin(MARGIN_RIGHT)), style->get_margin(MARGIN_TOP) + Math::floor((valign - _icon->get_height()) / 2.0)), _icon->get_size());
+						icon_region = Rect2(Point2(size.width - (icon_ofs_region + _icon->get_size().width + style->get_margin(SIDE_RIGHT)), style->get_margin(SIDE_TOP) + Math::floor((valign - _icon->get_height()) / 2.0)), _icon->get_size());
 					} else {
 						icon_region = Rect2(style->get_offset() + Point2(icon_ofs_region, Math::floor((valign - _icon->get_height()) / 2.0)), _icon->get_size());
 					}
@@ -248,28 +248,28 @@ void Button::_notification(int p_what) {
 
 			int text_width = clip_text ? MIN(text_clip, text_buf->get_size().x) : text_buf->get_size().x;
 
-			if (_internal_margin[MARGIN_LEFT] > 0) {
-				text_clip -= _internal_margin[MARGIN_LEFT] + get_theme_constant("hseparation");
+			if (_internal_margin[SIDE_LEFT] > 0) {
+				text_clip -= _internal_margin[SIDE_LEFT] + get_theme_constant("hseparation");
 			}
-			if (_internal_margin[MARGIN_RIGHT] > 0) {
-				text_clip -= _internal_margin[MARGIN_RIGHT] + get_theme_constant("hseparation");
+			if (_internal_margin[SIDE_RIGHT] > 0) {
+				text_clip -= _internal_margin[SIDE_RIGHT] + get_theme_constant("hseparation");
 			}
 
-			Point2 text_ofs = (size - style->get_minimum_size() - icon_ofs - text_buf->get_size() - Point2(_internal_margin[MARGIN_RIGHT] - _internal_margin[MARGIN_LEFT], 0)) / 2.0;
+			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) {
 				case ALIGN_LEFT: {
 					if (rtl) {
-						if (_internal_margin[MARGIN_RIGHT] > 0) {
-							text_ofs.x = size.x - style->get_margin(MARGIN_RIGHT) - text_width - _internal_margin[MARGIN_RIGHT] - get_theme_constant("hseparation");
+						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("hseparation");
 						} else {
-							text_ofs.x = size.x - style->get_margin(MARGIN_RIGHT) - text_width;
+							text_ofs.x = size.x - style->get_margin(SIDE_RIGHT) - text_width;
 						}
 					} else {
-						if (_internal_margin[MARGIN_LEFT] > 0) {
-							text_ofs.x = style->get_margin(MARGIN_LEFT) + icon_ofs.x + _internal_margin[MARGIN_LEFT] + get_theme_constant("hseparation");
+						if (_internal_margin[SIDE_LEFT] > 0) {
+							text_ofs.x = style->get_margin(SIDE_LEFT) + icon_ofs.x + _internal_margin[SIDE_LEFT] + get_theme_constant("hseparation");
 						} else {
-							text_ofs.x = style->get_margin(MARGIN_LEFT) + icon_ofs.x;
+							text_ofs.x = style->get_margin(SIDE_LEFT) + icon_ofs.x;
 						}
 					}
 					text_ofs.y += style->get_offset().y;
@@ -283,16 +283,16 @@ void Button::_notification(int p_what) {
 				} break;
 				case ALIGN_RIGHT: {
 					if (rtl) {
-						if (_internal_margin[MARGIN_LEFT] > 0) {
-							text_ofs.x = style->get_margin(MARGIN_LEFT) + icon_ofs.x + _internal_margin[MARGIN_LEFT] + get_theme_constant("hseparation");
+						if (_internal_margin[SIDE_LEFT] > 0) {
+							text_ofs.x = style->get_margin(SIDE_LEFT) + icon_ofs.x + _internal_margin[SIDE_LEFT] + get_theme_constant("hseparation");
 						} else {
-							text_ofs.x = style->get_margin(MARGIN_LEFT) + icon_ofs.x;
+							text_ofs.x = style->get_margin(SIDE_LEFT) + icon_ofs.x;
 						}
 					} else {
-						if (_internal_margin[MARGIN_RIGHT] > 0) {
-							text_ofs.x = size.x - style->get_margin(MARGIN_RIGHT) - text_width - _internal_margin[MARGIN_RIGHT] - get_theme_constant("hseparation");
+						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("hseparation");
 						} else {
-							text_ofs.x = size.x - style->get_margin(MARGIN_RIGHT) - text_width;
+							text_ofs.x = size.x - style->get_margin(SIDE_RIGHT) - text_width;
 						}
 					}
 					text_ofs.y += style->get_offset().y;
diff --git a/scene/gui/button.h b/scene/gui/button.h
index da89e5e6c4..f367448b86 100644
--- a/scene/gui/button.h
+++ b/scene/gui/button.h
@@ -63,7 +63,7 @@ private:
 	void _shape();
 
 protected:
-	void _set_internal_margin(Margin p_margin, float p_value);
+	void _set_internal_margin(Side p_side, float p_value);
 	void _notification(int p_what);
 	static void _bind_methods();
 
diff --git a/scene/gui/check_box.cpp b/scene/gui/check_box.cpp
index 0c78369688..bb274195f4 100644
--- a/scene/gui/check_box.cpp
+++ b/scene/gui/check_box.cpp
@@ -62,7 +62,7 @@ Size2 CheckBox::get_minimum_size() const {
 		minsize.width += get_theme_constant("hseparation");
 	}
 	Ref<StyleBox> sb = get_theme_stylebox("normal");
-	minsize.height = MAX(minsize.height, tex_size.height + sb->get_margin(MARGIN_TOP) + sb->get_margin(MARGIN_BOTTOM));
+	minsize.height = MAX(minsize.height, tex_size.height + sb->get_margin(SIDE_TOP) + sb->get_margin(SIDE_BOTTOM));
 
 	return minsize;
 }
@@ -70,11 +70,11 @@ Size2 CheckBox::get_minimum_size() const {
 void CheckBox::_notification(int p_what) {
 	if ((p_what == NOTIFICATION_THEME_CHANGED) || (p_what == NOTIFICATION_LAYOUT_DIRECTION_CHANGED || (p_what == NOTIFICATION_TRANSLATION_CHANGED))) {
 		if (is_layout_rtl()) {
-			_set_internal_margin(MARGIN_LEFT, 0.f);
-			_set_internal_margin(MARGIN_RIGHT, get_icon_size().width);
+			_set_internal_margin(SIDE_LEFT, 0.f);
+			_set_internal_margin(SIDE_RIGHT, get_icon_size().width);
 		} else {
-			_set_internal_margin(MARGIN_LEFT, get_icon_size().width);
-			_set_internal_margin(MARGIN_RIGHT, 0.f);
+			_set_internal_margin(SIDE_LEFT, get_icon_size().width);
+			_set_internal_margin(SIDE_RIGHT, 0.f);
 		}
 	} else if (p_what == NOTIFICATION_DRAW) {
 		RID ci = get_canvas_item();
@@ -85,9 +85,9 @@ void CheckBox::_notification(int p_what) {
 
 		Vector2 ofs;
 		if (is_layout_rtl()) {
-			ofs.x = get_size().x - sb->get_margin(MARGIN_RIGHT) - get_icon_size().width;
+			ofs.x = get_size().x - sb->get_margin(SIDE_RIGHT) - get_icon_size().width;
 		} else {
-			ofs.x = sb->get_margin(MARGIN_LEFT);
+			ofs.x = sb->get_margin(SIDE_LEFT);
 		}
 		ofs.y = int((get_size().height - get_icon_size().height) / 2) + get_theme_constant("check_vadjust");
 
@@ -110,9 +110,9 @@ CheckBox::CheckBox(const String &p_text) :
 	set_text_align(ALIGN_LEFT);
 
 	if (is_layout_rtl()) {
-		_set_internal_margin(MARGIN_RIGHT, get_icon_size().width);
+		_set_internal_margin(SIDE_RIGHT, get_icon_size().width);
 	} else {
-		_set_internal_margin(MARGIN_LEFT, get_icon_size().width);
+		_set_internal_margin(SIDE_LEFT, get_icon_size().width);
 	}
 }
 
diff --git a/scene/gui/check_button.cpp b/scene/gui/check_button.cpp
index e58f56a99b..2dd6cd1cb2 100644
--- a/scene/gui/check_button.cpp
+++ b/scene/gui/check_button.cpp
@@ -55,7 +55,7 @@ Size2 CheckButton::get_minimum_size() const {
 		minsize.width += get_theme_constant("hseparation");
 	}
 	Ref<StyleBox> sb = get_theme_stylebox("normal");
-	minsize.height = MAX(minsize.height, tex_size.height + sb->get_margin(MARGIN_TOP) + sb->get_margin(MARGIN_BOTTOM));
+	minsize.height = MAX(minsize.height, tex_size.height + sb->get_margin(SIDE_TOP) + sb->get_margin(SIDE_BOTTOM));
 
 	return minsize;
 }
@@ -63,11 +63,11 @@ Size2 CheckButton::get_minimum_size() const {
 void CheckButton::_notification(int p_what) {
 	if ((p_what == NOTIFICATION_THEME_CHANGED) || (p_what == NOTIFICATION_LAYOUT_DIRECTION_CHANGED) || (p_what == NOTIFICATION_TRANSLATION_CHANGED)) {
 		if (is_layout_rtl()) {
-			_set_internal_margin(MARGIN_LEFT, get_icon_size().width);
-			_set_internal_margin(MARGIN_RIGHT, 0.f);
+			_set_internal_margin(SIDE_LEFT, get_icon_size().width);
+			_set_internal_margin(SIDE_RIGHT, 0.f);
 		} else {
-			_set_internal_margin(MARGIN_LEFT, 0.f);
-			_set_internal_margin(MARGIN_RIGHT, get_icon_size().width);
+			_set_internal_margin(SIDE_LEFT, 0.f);
+			_set_internal_margin(SIDE_RIGHT, get_icon_size().width);
 		}
 	} else if (p_what == NOTIFICATION_DRAW) {
 		RID ci = get_canvas_item();
@@ -91,9 +91,9 @@ void CheckButton::_notification(int p_what) {
 		Size2 tex_size = get_icon_size();
 
 		if (rtl) {
-			ofs.x = sb->get_margin(MARGIN_LEFT);
+			ofs.x = sb->get_margin(SIDE_LEFT);
 		} else {
-			ofs.x = get_size().width - (tex_size.width + sb->get_margin(MARGIN_RIGHT));
+			ofs.x = get_size().width - (tex_size.width + sb->get_margin(SIDE_RIGHT));
 		}
 		ofs.y = (get_size().height - tex_size.height) / 2 + get_theme_constant("check_vadjust");
 
@@ -109,9 +109,9 @@ CheckButton::CheckButton() {
 	set_toggle_mode(true);
 	set_text_align(ALIGN_LEFT);
 	if (is_layout_rtl()) {
-		_set_internal_margin(MARGIN_LEFT, get_icon_size().width);
+		_set_internal_margin(SIDE_LEFT, get_icon_size().width);
 	} else {
-		_set_internal_margin(MARGIN_RIGHT, get_icon_size().width);
+		_set_internal_margin(SIDE_RIGHT, get_icon_size().width);
 	}
 }
 
diff --git a/scene/gui/color_picker.cpp b/scene/gui/color_picker.cpp
index 6ebd1011e9..8b02567d88 100644
--- a/scene/gui/color_picker.cpp
+++ b/scene/gui/color_picker.cpp
@@ -66,7 +66,7 @@ void ColorPicker::_notification(int p_what) {
 		} break;
 		case NOTIFICATION_PARENTED: {
 			for (int i = 0; i < 4; i++) {
-				set_margin((Margin)i, get_margin((Margin)i) + get_theme_constant("margin"));
+				set_offset((Side)i, get_offset((Side)i) + get_theme_constant("margin"));
 			}
 		} break;
 		case NOTIFICATION_VISIBILITY_CHANGED: {
@@ -611,7 +611,7 @@ void ColorPicker::_screen_pick_pressed() {
 		screen = memnew(Control);
 		r->add_child(screen);
 		screen->set_as_top_level(true);
-		screen->set_anchors_and_margins_preset(Control::PRESET_WIDE);
+		screen->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
 		screen->set_default_cursor_shape(CURSOR_POINTING_HAND);
 		screen->connect("gui_input", callable_mp(this, &ColorPicker::_screen_input));
 		// It immediately toggles off in the first press otherwise.
@@ -973,7 +973,7 @@ void ColorPickerButton::_update_picker() {
 		popup = memnew(PopupPanel);
 		popup->set_wrap_controls(true);
 		picker = memnew(ColorPicker);
-		picker->set_anchors_and_margins_preset(PRESET_WIDE);
+		picker->set_anchors_and_offsets_preset(PRESET_WIDE);
 		popup->add_child(picker);
 		add_child(popup);
 		picker->connect("color_changed", callable_mp(this, &ColorPickerButton::_color_changed));
diff --git a/scene/gui/control.cpp b/scene/gui/control.cpp
index bc37045386..62cbec4ae5 100644
--- a/scene/gui/control.cpp
+++ b/scene/gui/control.cpp
@@ -58,17 +58,17 @@ Dictionary Control::_edit_get_state() const {
 	s["scale"] = get_scale();
 	s["pivot"] = get_pivot_offset();
 	Array anchors;
-	anchors.push_back(get_anchor(MARGIN_LEFT));
-	anchors.push_back(get_anchor(MARGIN_TOP));
-	anchors.push_back(get_anchor(MARGIN_RIGHT));
-	anchors.push_back(get_anchor(MARGIN_BOTTOM));
+	anchors.push_back(get_anchor(SIDE_LEFT));
+	anchors.push_back(get_anchor(SIDE_TOP));
+	anchors.push_back(get_anchor(SIDE_RIGHT));
+	anchors.push_back(get_anchor(SIDE_BOTTOM));
 	s["anchors"] = anchors;
-	Array margins;
-	margins.push_back(get_margin(MARGIN_LEFT));
-	margins.push_back(get_margin(MARGIN_TOP));
-	margins.push_back(get_margin(MARGIN_RIGHT));
-	margins.push_back(get_margin(MARGIN_BOTTOM));
-	s["margins"] = margins;
+	Array offsets;
+	offsets.push_back(get_offset(SIDE_LEFT));
+	offsets.push_back(get_offset(SIDE_TOP));
+	offsets.push_back(get_offset(SIDE_RIGHT));
+	offsets.push_back(get_offset(SIDE_BOTTOM));
+	s["offsets"] = offsets;
 	return s;
 }
 
@@ -79,15 +79,15 @@ void Control::_edit_set_state(const Dictionary &p_state) {
 	set_scale(state["scale"]);
 	set_pivot_offset(state["pivot"]);
 	Array anchors = state["anchors"];
-	data.anchor[MARGIN_LEFT] = anchors[0];
-	data.anchor[MARGIN_TOP] = anchors[1];
-	data.anchor[MARGIN_RIGHT] = anchors[2];
-	data.anchor[MARGIN_BOTTOM] = anchors[3];
-	Array margins = state["margins"];
-	data.margin[MARGIN_LEFT] = margins[0];
-	data.margin[MARGIN_TOP] = margins[1];
-	data.margin[MARGIN_RIGHT] = margins[2];
-	data.margin[MARGIN_BOTTOM] = margins[3];
+	data.anchor[SIDE_LEFT] = anchors[0];
+	data.anchor[SIDE_TOP] = anchors[1];
+	data.anchor[SIDE_RIGHT] = anchors[2];
+	data.anchor[SIDE_BOTTOM] = anchors[3];
+	Array offsets = state["offsets"];
+	data.offset[SIDE_LEFT] = offsets[0];
+	data.offset[SIDE_TOP] = offsets[1];
+	data.offset[SIDE_RIGHT] = offsets[2];
+	data.offset[SIDE_BOTTOM] = offsets[3];
 	_size_changed();
 }
 
@@ -1227,15 +1227,15 @@ Size2 Control::get_parent_area_size() const {
 void Control::_size_changed() {
 	Rect2 parent_rect = get_parent_anchorable_rect();
 
-	float margin_pos[4];
+	float edge_pos[4];
 
 	for (int i = 0; i < 4; i++) {
 		float area = parent_rect.size[i & 1];
-		margin_pos[i] = data.margin[i] + (data.anchor[i] * area);
+		edge_pos[i] = data.offset[i] + (data.anchor[i] * area);
 	}
 
-	Point2 new_pos_cache = Point2(margin_pos[0], margin_pos[1]);
-	Size2 new_size_cache = Point2(margin_pos[2], margin_pos[3]) - new_pos_cache;
+	Point2 new_pos_cache = Point2(edge_pos[0], edge_pos[1]);
+	Size2 new_size_cache = Point2(edge_pos[2], edge_pos[3]) - new_pos_cache;
 
 	Size2 minimum_size = get_combined_minimum_size();
 
@@ -1275,7 +1275,7 @@ void Control::_size_changed() {
 		}
 		if (pos_changed || size_changed) {
 			item_rect_changed(size_changed);
-			_change_notify_margins();
+			_change_notify_offsets();
 			_notify_transform();
 		}
 
@@ -1285,29 +1285,29 @@ void Control::_size_changed() {
 	}
 }
 
-void Control::set_anchor(Margin p_margin, float p_anchor, bool p_keep_margin, bool p_push_opposite_anchor) {
-	ERR_FAIL_INDEX((int)p_margin, 4);
+void Control::set_anchor(Side p_side, float p_anchor, bool p_keep_offset, bool p_push_opposite_anchor) {
+	ERR_FAIL_INDEX((int)p_side, 4);
 
 	Rect2 parent_rect = get_parent_anchorable_rect();
-	float parent_range = (p_margin == MARGIN_LEFT || p_margin == MARGIN_RIGHT) ? parent_rect.size.x : parent_rect.size.y;
-	float previous_margin_pos = data.margin[p_margin] + data.anchor[p_margin] * parent_range;
-	float previous_opposite_margin_pos = data.margin[(p_margin + 2) % 4] + data.anchor[(p_margin + 2) % 4] * parent_range;
+	float parent_range = (p_side == SIDE_LEFT || p_side == SIDE_RIGHT) ? parent_rect.size.x : parent_rect.size.y;
+	float previous_pos = data.offset[p_side] + data.anchor[p_side] * parent_range;
+	float previous_opposite_pos = data.offset[(p_side + 2) % 4] + data.anchor[(p_side + 2) % 4] * parent_range;
 
-	data.anchor[p_margin] = p_anchor;
+	data.anchor[p_side] = p_anchor;
 
-	if (((p_margin == MARGIN_LEFT || p_margin == MARGIN_TOP) && data.anchor[p_margin] > data.anchor[(p_margin + 2) % 4]) ||
-			((p_margin == MARGIN_RIGHT || p_margin == MARGIN_BOTTOM) && data.anchor[p_margin] < data.anchor[(p_margin + 2) % 4])) {
+	if (((p_side == SIDE_LEFT || p_side == SIDE_TOP) && data.anchor[p_side] > data.anchor[(p_side + 2) % 4]) ||
+			((p_side == SIDE_RIGHT || p_side == SIDE_BOTTOM) && data.anchor[p_side] < data.anchor[(p_side + 2) % 4])) {
 		if (p_push_opposite_anchor) {
-			data.anchor[(p_margin + 2) % 4] = data.anchor[p_margin];
+			data.anchor[(p_side + 2) % 4] = data.anchor[p_side];
 		} else {
-			data.anchor[p_margin] = data.anchor[(p_margin + 2) % 4];
+			data.anchor[p_side] = data.anchor[(p_side + 2) % 4];
 		}
 	}
 
-	if (!p_keep_margin) {
-		data.margin[p_margin] = previous_margin_pos - data.anchor[p_margin] * parent_range;
+	if (!p_keep_offset) {
+		data.offset[p_side] = previous_pos - data.anchor[p_side] * parent_range;
 		if (p_push_opposite_anchor) {
-			data.margin[(p_margin + 2) % 4] = previous_opposite_margin_pos - data.anchor[(p_margin + 2) % 4] * parent_range;
+			data.offset[(p_side + 2) % 4] = previous_opposite_pos - data.anchor[(p_side + 2) % 4] * parent_range;
 		}
 	}
 	if (is_inside_tree()) {
@@ -1321,16 +1321,16 @@ void Control::set_anchor(Margin p_margin, float p_anchor, bool p_keep_margin, bo
 	_change_notify("anchor_bottom");
 }
 
-void Control::_set_anchor(Margin p_margin, float p_anchor) {
-	set_anchor(p_margin, p_anchor);
+void Control::_set_anchor(Side p_side, float p_anchor) {
+	set_anchor(p_side, p_anchor);
 }
 
-void Control::set_anchor_and_margin(Margin p_margin, float p_anchor, float p_pos, bool p_push_opposite_anchor) {
-	set_anchor(p_margin, p_anchor, false, p_push_opposite_anchor);
-	set_margin(p_margin, p_pos);
+void Control::set_anchor_and_offset(Side p_side, float p_anchor, float p_pos, bool p_push_opposite_anchor) {
+	set_anchor(p_side, p_anchor, false, p_push_opposite_anchor);
+	set_offset(p_side, p_pos);
 }
 
-void Control::set_anchors_preset(LayoutPreset p_preset, bool p_keep_margins) {
+void Control::set_anchors_preset(LayoutPreset p_preset, bool p_keep_offsets) {
 	ERR_FAIL_INDEX((int)p_preset, 16);
 
 	//Left
@@ -1343,21 +1343,21 @@ void Control::set_anchors_preset(LayoutPreset p_preset, bool p_keep_margins) {
 		case PRESET_LEFT_WIDE:
 		case PRESET_HCENTER_WIDE:
 		case PRESET_WIDE:
-			set_anchor(MARGIN_LEFT, ANCHOR_BEGIN, p_keep_margins);
+			set_anchor(SIDE_LEFT, ANCHOR_BEGIN, p_keep_offsets);
 			break;
 
 		case PRESET_CENTER_TOP:
 		case PRESET_CENTER_BOTTOM:
 		case PRESET_CENTER:
 		case PRESET_VCENTER_WIDE:
-			set_anchor(MARGIN_LEFT, 0.5, p_keep_margins);
+			set_anchor(SIDE_LEFT, 0.5, p_keep_offsets);
 			break;
 
 		case PRESET_TOP_RIGHT:
 		case PRESET_BOTTOM_RIGHT:
 		case PRESET_CENTER_RIGHT:
 		case PRESET_RIGHT_WIDE:
-			set_anchor(MARGIN_LEFT, ANCHOR_END, p_keep_margins);
+			set_anchor(SIDE_LEFT, ANCHOR_END, p_keep_offsets);
 			break;
 	}
 
@@ -1371,21 +1371,21 @@ void Control::set_anchors_preset(LayoutPreset p_preset, bool p_keep_margins) {
 		case PRESET_TOP_WIDE:
 		case PRESET_VCENTER_WIDE:
 		case PRESET_WIDE:
-			set_anchor(MARGIN_TOP, ANCHOR_BEGIN, p_keep_margins);
+			set_anchor(SIDE_TOP, ANCHOR_BEGIN, p_keep_offsets);
 			break;
 
 		case PRESET_CENTER_LEFT:
 		case PRESET_CENTER_RIGHT:
 		case PRESET_CENTER:
 		case PRESET_HCENTER_WIDE:
-			set_anchor(MARGIN_TOP, 0.5, p_keep_margins);
+			set_anchor(SIDE_TOP, 0.5, p_keep_offsets);
 			break;
 
 		case PRESET_BOTTOM_LEFT:
 		case PRESET_BOTTOM_RIGHT:
 		case PRESET_CENTER_BOTTOM:
 		case PRESET_BOTTOM_WIDE:
-			set_anchor(MARGIN_TOP, ANCHOR_END, p_keep_margins);
+			set_anchor(SIDE_TOP, ANCHOR_END, p_keep_offsets);
 			break;
 	}
 
@@ -1395,14 +1395,14 @@ void Control::set_anchors_preset(LayoutPreset p_preset, bool p_keep_margins) {
 		case PRESET_BOTTOM_LEFT:
 		case PRESET_CENTER_LEFT:
 		case PRESET_LEFT_WIDE:
-			set_anchor(MARGIN_RIGHT, ANCHOR_BEGIN, p_keep_margins);
+			set_anchor(SIDE_RIGHT, ANCHOR_BEGIN, p_keep_offsets);
 			break;
 
 		case PRESET_CENTER_TOP:
 		case PRESET_CENTER_BOTTOM:
 		case PRESET_CENTER:
 		case PRESET_VCENTER_WIDE:
-			set_anchor(MARGIN_RIGHT, 0.5, p_keep_margins);
+			set_anchor(SIDE_RIGHT, 0.5, p_keep_offsets);
 			break;
 
 		case PRESET_TOP_RIGHT:
@@ -1413,7 +1413,7 @@ void Control::set_anchors_preset(LayoutPreset p_preset, bool p_keep_margins) {
 		case PRESET_BOTTOM_WIDE:
 		case PRESET_HCENTER_WIDE:
 		case PRESET_WIDE:
-			set_anchor(MARGIN_RIGHT, ANCHOR_END, p_keep_margins);
+			set_anchor(SIDE_RIGHT, ANCHOR_END, p_keep_offsets);
 			break;
 	}
 
@@ -1423,14 +1423,14 @@ void Control::set_anchors_preset(LayoutPreset p_preset, bool p_keep_margins) {
 		case PRESET_TOP_RIGHT:
 		case PRESET_CENTER_TOP:
 		case PRESET_TOP_WIDE:
-			set_anchor(MARGIN_BOTTOM, ANCHOR_BEGIN, p_keep_margins);
+			set_anchor(SIDE_BOTTOM, ANCHOR_BEGIN, p_keep_offsets);
 			break;
 
 		case PRESET_CENTER_LEFT:
 		case PRESET_CENTER_RIGHT:
 		case PRESET_CENTER:
 		case PRESET_HCENTER_WIDE:
-			set_anchor(MARGIN_BOTTOM, 0.5, p_keep_margins);
+			set_anchor(SIDE_BOTTOM, 0.5, p_keep_offsets);
 			break;
 
 		case PRESET_BOTTOM_LEFT:
@@ -1441,12 +1441,12 @@ void Control::set_anchors_preset(LayoutPreset p_preset, bool p_keep_margins) {
 		case PRESET_BOTTOM_WIDE:
 		case PRESET_VCENTER_WIDE:
 		case PRESET_WIDE:
-			set_anchor(MARGIN_BOTTOM, ANCHOR_END, p_keep_margins);
+			set_anchor(SIDE_BOTTOM, ANCHOR_END, p_keep_offsets);
 			break;
 	}
 }
 
-void Control::set_margins_preset(LayoutPreset p_preset, LayoutPresetMode p_resize_mode, int p_margin) {
+void Control::set_offsets_preset(LayoutPreset p_preset, LayoutPresetMode p_resize_mode, int p_margin) {
 	ERR_FAIL_INDEX((int)p_preset, 16);
 	ERR_FAIL_INDEX((int)p_resize_mode, 4);
 
@@ -1476,21 +1476,21 @@ void Control::set_margins_preset(LayoutPreset p_preset, LayoutPresetMode p_resiz
 		case PRESET_LEFT_WIDE:
 		case PRESET_HCENTER_WIDE:
 		case PRESET_WIDE:
-			data.margin[0] = x * (0.0 - data.anchor[0]) + p_margin + parent_rect.position.x;
+			data.offset[0] = x * (0.0 - data.anchor[0]) + p_margin + parent_rect.position.x;
 			break;
 
 		case PRESET_CENTER_TOP:
 		case PRESET_CENTER_BOTTOM:
 		case PRESET_CENTER:
 		case PRESET_VCENTER_WIDE:
-			data.margin[0] = x * (0.5 - data.anchor[0]) - new_size.x / 2 + parent_rect.position.x;
+			data.offset[0] = x * (0.5 - data.anchor[0]) - new_size.x / 2 + parent_rect.position.x;
 			break;
 
 		case PRESET_TOP_RIGHT:
 		case PRESET_BOTTOM_RIGHT:
 		case PRESET_CENTER_RIGHT:
 		case PRESET_RIGHT_WIDE:
-			data.margin[0] = x * (1.0 - data.anchor[0]) - new_size.x - p_margin + parent_rect.position.x;
+			data.offset[0] = x * (1.0 - data.anchor[0]) - new_size.x - p_margin + parent_rect.position.x;
 			break;
 	}
 
@@ -1504,21 +1504,21 @@ void Control::set_margins_preset(LayoutPreset p_preset, LayoutPresetMode p_resiz
 		case PRESET_TOP_WIDE:
 		case PRESET_VCENTER_WIDE:
 		case PRESET_WIDE:
-			data.margin[1] = parent_rect.size.y * (0.0 - data.anchor[1]) + p_margin + parent_rect.position.y;
+			data.offset[1] = parent_rect.size.y * (0.0 - data.anchor[1]) + p_margin + parent_rect.position.y;
 			break;
 
 		case PRESET_CENTER_LEFT:
 		case PRESET_CENTER_RIGHT:
 		case PRESET_CENTER:
 		case PRESET_HCENTER_WIDE:
-			data.margin[1] = parent_rect.size.y * (0.5 - data.anchor[1]) - new_size.y / 2 + parent_rect.position.y;
+			data.offset[1] = parent_rect.size.y * (0.5 - data.anchor[1]) - new_size.y / 2 + parent_rect.position.y;
 			break;
 
 		case PRESET_BOTTOM_LEFT:
 		case PRESET_BOTTOM_RIGHT:
 		case PRESET_CENTER_BOTTOM:
 		case PRESET_BOTTOM_WIDE:
-			data.margin[1] = parent_rect.size.y * (1.0 - data.anchor[1]) - new_size.y - p_margin + parent_rect.position.y;
+			data.offset[1] = parent_rect.size.y * (1.0 - data.anchor[1]) - new_size.y - p_margin + parent_rect.position.y;
 			break;
 	}
 
@@ -1528,14 +1528,14 @@ void Control::set_margins_preset(LayoutPreset p_preset, LayoutPresetMode p_resiz
 		case PRESET_BOTTOM_LEFT:
 		case PRESET_CENTER_LEFT:
 		case PRESET_LEFT_WIDE:
-			data.margin[2] = x * (0.0 - data.anchor[2]) + new_size.x + p_margin + parent_rect.position.x;
+			data.offset[2] = x * (0.0 - data.anchor[2]) + new_size.x + p_margin + parent_rect.position.x;
 			break;
 
 		case PRESET_CENTER_TOP:
 		case PRESET_CENTER_BOTTOM:
 		case PRESET_CENTER:
 		case PRESET_VCENTER_WIDE:
-			data.margin[2] = x * (0.5 - data.anchor[2]) + new_size.x / 2 + parent_rect.position.x;
+			data.offset[2] = x * (0.5 - data.anchor[2]) + new_size.x / 2 + parent_rect.position.x;
 			break;
 
 		case PRESET_TOP_RIGHT:
@@ -1546,7 +1546,7 @@ void Control::set_margins_preset(LayoutPreset p_preset, LayoutPresetMode p_resiz
 		case PRESET_BOTTOM_WIDE:
 		case PRESET_HCENTER_WIDE:
 		case PRESET_WIDE:
-			data.margin[2] = x * (1.0 - data.anchor[2]) - p_margin + parent_rect.position.x;
+			data.offset[2] = x * (1.0 - data.anchor[2]) - p_margin + parent_rect.position.x;
 			break;
 	}
 
@@ -1556,14 +1556,14 @@ void Control::set_margins_preset(LayoutPreset p_preset, LayoutPresetMode p_resiz
 		case PRESET_TOP_RIGHT:
 		case PRESET_CENTER_TOP:
 		case PRESET_TOP_WIDE:
-			data.margin[3] = parent_rect.size.y * (0.0 - data.anchor[3]) + new_size.y + p_margin + parent_rect.position.y;
+			data.offset[3] = parent_rect.size.y * (0.0 - data.anchor[3]) + new_size.y + p_margin + parent_rect.position.y;
 			break;
 
 		case PRESET_CENTER_LEFT:
 		case PRESET_CENTER_RIGHT:
 		case PRESET_CENTER:
 		case PRESET_HCENTER_WIDE:
-			data.margin[3] = parent_rect.size.y * (0.5 - data.anchor[3]) + new_size.y / 2 + parent_rect.position.y;
+			data.offset[3] = parent_rect.size.y * (0.5 - data.anchor[3]) + new_size.y / 2 + parent_rect.position.y;
 			break;
 
 		case PRESET_BOTTOM_LEFT:
@@ -1574,65 +1574,65 @@ void Control::set_margins_preset(LayoutPreset p_preset, LayoutPresetMode p_resiz
 		case PRESET_BOTTOM_WIDE:
 		case PRESET_VCENTER_WIDE:
 		case PRESET_WIDE:
-			data.margin[3] = parent_rect.size.y * (1.0 - data.anchor[3]) - p_margin + parent_rect.position.y;
+			data.offset[3] = parent_rect.size.y * (1.0 - data.anchor[3]) - p_margin + parent_rect.position.y;
 			break;
 	}
 
 	_size_changed();
 }
 
-void Control::set_anchors_and_margins_preset(LayoutPreset p_preset, LayoutPresetMode p_resize_mode, int p_margin) {
+void Control::set_anchors_and_offsets_preset(LayoutPreset p_preset, LayoutPresetMode p_resize_mode, int p_margin) {
 	set_anchors_preset(p_preset);
-	set_margins_preset(p_preset, p_resize_mode, p_margin);
+	set_offsets_preset(p_preset, p_resize_mode, p_margin);
 }
 
-float Control::get_anchor(Margin p_margin) const {
-	ERR_FAIL_INDEX_V(int(p_margin), 4, 0.0);
+float Control::get_anchor(Side p_side) const {
+	ERR_FAIL_INDEX_V(int(p_side), 4, 0.0);
 
-	return data.anchor[p_margin];
+	return data.anchor[p_side];
 }
 
-void Control::_change_notify_margins() {
+void Control::_change_notify_offsets() {
 	// this avoids sending the whole object data again on a change
-	_change_notify("margin_left");
-	_change_notify("margin_top");
-	_change_notify("margin_right");
-	_change_notify("margin_bottom");
+	_change_notify("offset_left");
+	_change_notify("offset_top");
+	_change_notify("offset_right");
+	_change_notify("offset_bottom");
 	_change_notify("rect_position");
 	_change_notify("rect_size");
 }
 
-void Control::set_margin(Margin p_margin, float p_value) {
-	ERR_FAIL_INDEX((int)p_margin, 4);
+void Control::set_offset(Side p_side, float p_value) {
+	ERR_FAIL_INDEX((int)p_side, 4);
 
-	data.margin[p_margin] = p_value;
+	data.offset[p_side] = p_value;
 	_size_changed();
 }
 
 void Control::set_begin(const Size2 &p_point) {
-	data.margin[0] = p_point.x;
-	data.margin[1] = p_point.y;
+	data.offset[0] = p_point.x;
+	data.offset[1] = p_point.y;
 	_size_changed();
 }
 
 void Control::set_end(const Size2 &p_point) {
-	data.margin[2] = p_point.x;
-	data.margin[3] = p_point.y;
+	data.offset[2] = p_point.x;
+	data.offset[3] = p_point.y;
 	_size_changed();
 }
 
-float Control::get_margin(Margin p_margin) const {
-	ERR_FAIL_INDEX_V((int)p_margin, 4, 0);
+float Control::get_offset(Side p_side) const {
+	ERR_FAIL_INDEX_V((int)p_side, 4, 0);
 
-	return data.margin[p_margin];
+	return data.offset[p_side];
 }
 
 Size2 Control::get_begin() const {
-	return Size2(data.margin[0], data.margin[1]);
+	return Size2(data.offset[0], data.offset[1]);
 }
 
 Size2 Control::get_end() const {
-	return Size2(data.margin[2], data.margin[3]);
+	return Size2(data.offset[2], data.offset[3]);
 }
 
 Point2 Control::get_global_position() const {
@@ -1654,17 +1654,17 @@ void Control::_set_global_position(const Point2 &p_point) {
 	set_global_position(p_point);
 }
 
-void Control::set_global_position(const Point2 &p_point, bool p_keep_margins) {
+void Control::set_global_position(const Point2 &p_point, bool p_keep_offsets) {
 	Transform2D inv;
 
 	if (data.parent_canvas_item) {
 		inv = data.parent_canvas_item->get_global_transform().affine_inverse();
 	}
 
-	set_position(inv.xform(p_point), p_keep_margins);
+	set_position(inv.xform(p_point), p_keep_offsets);
 }
 
-void Control::_compute_anchors(Rect2 p_rect, const float p_margins[4], float (&r_anchors)[4]) {
+void Control::_compute_anchors(Rect2 p_rect, const float p_offsets[4], float (&r_anchors)[4]) {
 	Size2 parent_rect_size = get_parent_anchorable_rect().size;
 	ERR_FAIL_COND(parent_rect_size.x == 0.0);
 	ERR_FAIL_COND(parent_rect_size.y == 0.0);
@@ -1673,38 +1673,38 @@ void Control::_compute_anchors(Rect2 p_rect, const float p_margins[4], float (&r
 	if (is_layout_rtl()) {
 		x = parent_rect_size.x - x - p_rect.size.x;
 	}
-	r_anchors[0] = (x - p_margins[0]) / parent_rect_size.x;
-	r_anchors[1] = (p_rect.position.y - p_margins[1]) / parent_rect_size.y;
-	r_anchors[2] = (x + p_rect.size.x - p_margins[2]) / parent_rect_size.x;
-	r_anchors[3] = (p_rect.position.y + p_rect.size.y - p_margins[3]) / parent_rect_size.y;
+	r_anchors[0] = (x - p_offsets[0]) / parent_rect_size.x;
+	r_anchors[1] = (p_rect.position.y - p_offsets[1]) / parent_rect_size.y;
+	r_anchors[2] = (x + p_rect.size.x - p_offsets[2]) / parent_rect_size.x;
+	r_anchors[3] = (p_rect.position.y + p_rect.size.y - p_offsets[3]) / parent_rect_size.y;
 }
 
-void Control::_compute_margins(Rect2 p_rect, const float p_anchors[4], float (&r_margins)[4]) {
+void Control::_compute_offsets(Rect2 p_rect, const float p_anchors[4], float (&r_offsets)[4]) {
 	Size2 parent_rect_size = get_parent_anchorable_rect().size;
 
 	float x = p_rect.position.x;
 	if (is_layout_rtl()) {
 		x = parent_rect_size.x - x - p_rect.size.x;
 	}
-	r_margins[0] = x - (p_anchors[0] * parent_rect_size.x);
-	r_margins[1] = p_rect.position.y - (p_anchors[1] * parent_rect_size.y);
-	r_margins[2] = x + p_rect.size.x - (p_anchors[2] * parent_rect_size.x);
-	r_margins[3] = p_rect.position.y + p_rect.size.y - (p_anchors[3] * parent_rect_size.y);
+	r_offsets[0] = x - (p_anchors[0] * parent_rect_size.x);
+	r_offsets[1] = p_rect.position.y - (p_anchors[1] * parent_rect_size.y);
+	r_offsets[2] = x + p_rect.size.x - (p_anchors[2] * parent_rect_size.x);
+	r_offsets[3] = p_rect.position.y + p_rect.size.y - (p_anchors[3] * parent_rect_size.y);
 }
 
 void Control::_set_position(const Size2 &p_point) {
 	set_position(p_point);
 }
 
-void Control::set_position(const Size2 &p_point, bool p_keep_margins) {
-	if (p_keep_margins) {
-		_compute_anchors(Rect2(p_point, data.size_cache), data.margin, data.anchor);
+void Control::set_position(const Size2 &p_point, bool p_keep_offsets) {
+	if (p_keep_offsets) {
+		_compute_anchors(Rect2(p_point, data.size_cache), data.offset, data.anchor);
 		_change_notify("anchor_left");
 		_change_notify("anchor_right");
 		_change_notify("anchor_top");
 		_change_notify("anchor_bottom");
 	} else {
-		_compute_margins(Rect2(p_point, data.size_cache), data.anchor, data.margin);
+		_compute_offsets(Rect2(p_point, data.size_cache), data.anchor, data.offset);
 	}
 	_size_changed();
 }
@@ -1714,7 +1714,7 @@ void Control::set_rect(const Rect2 &p_rect) {
 		data.anchor[i] = ANCHOR_BEGIN;
 	}
 
-	_compute_margins(p_rect, data.anchor, data.margin);
+	_compute_offsets(p_rect, data.anchor, data.offset);
 	if (is_inside_tree()) {
 		_size_changed();
 	}
@@ -1724,7 +1724,7 @@ void Control::_set_size(const Size2 &p_size) {
 	set_size(p_size);
 }
 
-void Control::set_size(const Size2 &p_size, bool p_keep_margins) {
+void Control::set_size(const Size2 &p_size, bool p_keep_offsets) {
 	Size2 new_size = p_size;
 	Size2 min = get_combined_minimum_size();
 	if (new_size.x < min.x) {
@@ -1734,14 +1734,14 @@ void Control::set_size(const Size2 &p_size, bool p_keep_margins) {
 		new_size.y = min.y;
 	}
 
-	if (p_keep_margins) {
-		_compute_anchors(Rect2(data.pos_cache, new_size), data.margin, data.anchor);
+	if (p_keep_offsets) {
+		_compute_anchors(Rect2(data.pos_cache, new_size), data.offset, data.anchor);
 		_change_notify("anchor_left");
 		_change_notify("anchor_right");
 		_change_notify("anchor_top");
 		_change_notify("anchor_bottom");
 	} else {
-		_compute_margins(Rect2(data.pos_cache, new_size), data.anchor, data.margin);
+		_compute_offsets(Rect2(data.pos_cache, new_size), data.anchor, data.offset);
 	}
 	_size_changed();
 }
@@ -2206,14 +2206,14 @@ String Control::_get_tooltip() const {
 	return data.tooltip;
 }
 
-void Control::set_focus_neighbor(Margin p_margin, const NodePath &p_neighbor) {
-	ERR_FAIL_INDEX((int)p_margin, 4);
-	data.focus_neighbor[p_margin] = p_neighbor;
+void Control::set_focus_neighbor(Side p_side, const NodePath &p_neighbor) {
+	ERR_FAIL_INDEX((int)p_side, 4);
+	data.focus_neighbor[p_side] = p_neighbor;
 }
 
-NodePath Control::get_focus_neighbor(Margin p_margin) const {
-	ERR_FAIL_INDEX_V((int)p_margin, 4, NodePath());
-	return data.focus_neighbor[p_margin];
+NodePath Control::get_focus_neighbor(Side p_side) const {
+	ERR_FAIL_INDEX_V((int)p_side, 4, NodePath());
+	return data.focus_neighbor[p_side];
 }
 
 void Control::set_focus_next(const NodePath &p_next) {
@@ -2234,15 +2234,15 @@ NodePath Control::get_focus_previous() const {
 
 #define MAX_NEIGHBOR_SEARCH_COUNT 512
 
-Control *Control::_get_focus_neighbor(Margin p_margin, int p_count) {
-	ERR_FAIL_INDEX_V((int)p_margin, 4, nullptr);
+Control *Control::_get_focus_neighbor(Side p_side, int p_count) {
+	ERR_FAIL_INDEX_V((int)p_side, 4, nullptr);
 
 	if (p_count >= MAX_NEIGHBOR_SEARCH_COUNT) {
 		return nullptr;
 	}
-	if (!data.focus_neighbor[p_margin].is_empty()) {
+	if (!data.focus_neighbor[p_side].is_empty()) {
 		Control *c = nullptr;
-		Node *n = get_node(data.focus_neighbor[p_margin]);
+		Node *n = get_node(data.focus_neighbor[p_side]);
 		if (n) {
 			c = Object::cast_to<Control>(n);
 			ERR_FAIL_COND_V_MSG(!c, nullptr, "Neighbor focus node is not a control: " + n->get_name() + ".");
@@ -2260,7 +2260,7 @@ Control *Control::_get_focus_neighbor(Margin p_margin, int p_count) {
 			return c;
 		}
 
-		c = c->_get_focus_neighbor(p_margin, p_count + 1);
+		c = c->_get_focus_neighbor(p_side, p_count + 1);
 		return c;
 	}
 
@@ -2283,7 +2283,7 @@ Control *Control::_get_focus_neighbor(Margin p_margin, int p_count) {
 		Vector2(0, 1)
 	};
 
-	Vector2 vdir = dir[p_margin];
+	Vector2 vdir = dir[p_side];
 
 	float maxd = -1e7;
 
@@ -2745,28 +2745,28 @@ void Control::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("accept_event"), &Control::accept_event);
 	ClassDB::bind_method(D_METHOD("get_minimum_size"), &Control::get_minimum_size);
 	ClassDB::bind_method(D_METHOD("get_combined_minimum_size"), &Control::get_combined_minimum_size);
-	ClassDB::bind_method(D_METHOD("set_anchors_preset", "preset", "keep_margins"), &Control::set_anchors_preset, DEFVAL(false));
-	ClassDB::bind_method(D_METHOD("set_margins_preset", "preset", "resize_mode", "margin"), &Control::set_margins_preset, DEFVAL(PRESET_MODE_MINSIZE), DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("set_anchors_and_margins_preset", "preset", "resize_mode", "margin"), &Control::set_anchors_and_margins_preset, DEFVAL(PRESET_MODE_MINSIZE), DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("_set_anchor", "margin", "anchor"), &Control::_set_anchor);
-	ClassDB::bind_method(D_METHOD("set_anchor", "margin", "anchor", "keep_margin", "push_opposite_anchor"), &Control::set_anchor, DEFVAL(false), DEFVAL(true));
-	ClassDB::bind_method(D_METHOD("get_anchor", "margin"), &Control::get_anchor);
-	ClassDB::bind_method(D_METHOD("set_margin", "margin", "offset"), &Control::set_margin);
-	ClassDB::bind_method(D_METHOD("set_anchor_and_margin", "margin", "anchor", "offset", "push_opposite_anchor"), &Control::set_anchor_and_margin, DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("set_anchors_preset", "preset", "keep_offsets"), &Control::set_anchors_preset, DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("set_offsets_preset", "preset", "resize_mode", "margin"), &Control::set_offsets_preset, DEFVAL(PRESET_MODE_MINSIZE), DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("set_anchors_and_offsets_preset", "preset", "resize_mode", "margin"), &Control::set_anchors_and_offsets_preset, DEFVAL(PRESET_MODE_MINSIZE), DEFVAL(0));
+	ClassDB::bind_method(D_METHOD("_set_anchor", "side", "anchor"), &Control::_set_anchor);
+	ClassDB::bind_method(D_METHOD("set_anchor", "side", "anchor", "keep_offset", "push_opposite_anchor"), &Control::set_anchor, DEFVAL(false), DEFVAL(true));
+	ClassDB::bind_method(D_METHOD("get_anchor", "side"), &Control::get_anchor);
+	ClassDB::bind_method(D_METHOD("set_offset", "side", "offset"), &Control::set_offset);
+	ClassDB::bind_method(D_METHOD("set_anchor_and_offset", "side", "anchor", "offset", "push_opposite_anchor"), &Control::set_anchor_and_offset, DEFVAL(false));
 	ClassDB::bind_method(D_METHOD("set_begin", "position"), &Control::set_begin);
 	ClassDB::bind_method(D_METHOD("set_end", "position"), &Control::set_end);
-	ClassDB::bind_method(D_METHOD("set_position", "position", "keep_margins"), &Control::set_position, DEFVAL(false));
-	ClassDB::bind_method(D_METHOD("_set_position", "margin"), &Control::_set_position);
-	ClassDB::bind_method(D_METHOD("set_size", "size", "keep_margins"), &Control::set_size, DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("set_position", "position", "keep_offsets"), &Control::set_position, DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("_set_position", "position"), &Control::_set_position);
+	ClassDB::bind_method(D_METHOD("set_size", "size", "keep_offsets"), &Control::set_size, DEFVAL(false));
 	ClassDB::bind_method(D_METHOD("_set_size", "size"), &Control::_set_size);
 	ClassDB::bind_method(D_METHOD("set_custom_minimum_size", "size"), &Control::set_custom_minimum_size);
-	ClassDB::bind_method(D_METHOD("set_global_position", "position", "keep_margins"), &Control::set_global_position, DEFVAL(false));
+	ClassDB::bind_method(D_METHOD("set_global_position", "position", "keep_offsets"), &Control::set_global_position, DEFVAL(false));
 	ClassDB::bind_method(D_METHOD("_set_global_position", "position"), &Control::_set_global_position);
 	ClassDB::bind_method(D_METHOD("set_rotation", "radians"), &Control::set_rotation);
 	ClassDB::bind_method(D_METHOD("set_rotation_degrees", "degrees"), &Control::set_rotation_degrees);
 	ClassDB::bind_method(D_METHOD("set_scale", "scale"), &Control::set_scale);
 	ClassDB::bind_method(D_METHOD("set_pivot_offset", "pivot_offset"), &Control::set_pivot_offset);
-	ClassDB::bind_method(D_METHOD("get_margin", "margin"), &Control::get_margin);
+	ClassDB::bind_method(D_METHOD("get_offset", "offset"), &Control::get_offset);
 	ClassDB::bind_method(D_METHOD("get_begin"), &Control::get_begin);
 	ClassDB::bind_method(D_METHOD("get_end"), &Control::get_end);
 	ClassDB::bind_method(D_METHOD("get_position"), &Control::get_position);
@@ -2843,8 +2843,8 @@ void Control::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_default_cursor_shape"), &Control::get_default_cursor_shape);
 	ClassDB::bind_method(D_METHOD("get_cursor_shape", "position"), &Control::get_cursor_shape, DEFVAL(Point2()));
 
-	ClassDB::bind_method(D_METHOD("set_focus_neighbor", "margin", "neighbor"), &Control::set_focus_neighbor);
-	ClassDB::bind_method(D_METHOD("get_focus_neighbor", "margin"), &Control::get_focus_neighbor);
+	ClassDB::bind_method(D_METHOD("set_focus_neighbor", "side", "neighbor"), &Control::set_focus_neighbor);
+	ClassDB::bind_method(D_METHOD("get_focus_neighbor", "side"), &Control::get_focus_neighbor);
 
 	ClassDB::bind_method(D_METHOD("set_focus_next", "next"), &Control::set_focus_next);
 	ClassDB::bind_method(D_METHOD("get_focus_next"), &Control::get_focus_next);
@@ -2890,16 +2890,16 @@ void Control::_bind_methods() {
 	BIND_VMETHOD(MethodInfo(Variant::BOOL, "_clips_input"));
 
 	ADD_GROUP("Anchor", "anchor_");
-	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "anchor_left", PROPERTY_HINT_RANGE, "0,1,0.001,or_lesser,or_greater"), "_set_anchor", "get_anchor", MARGIN_LEFT);
-	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "anchor_top", PROPERTY_HINT_RANGE, "0,1,0.001,or_lesser,or_greater"), "_set_anchor", "get_anchor", MARGIN_TOP);
-	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "anchor_right", PROPERTY_HINT_RANGE, "0,1,0.001,or_lesser,or_greater"), "_set_anchor", "get_anchor", MARGIN_RIGHT);
-	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "anchor_bottom", PROPERTY_HINT_RANGE, "0,1,0.001,or_lesser,or_greater"), "_set_anchor", "get_anchor", MARGIN_BOTTOM);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "anchor_left", PROPERTY_HINT_RANGE, "0,1,0.001,or_lesser,or_greater"), "_set_anchor", "get_anchor", SIDE_LEFT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "anchor_top", PROPERTY_HINT_RANGE, "0,1,0.001,or_lesser,or_greater"), "_set_anchor", "get_anchor", SIDE_TOP);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "anchor_right", PROPERTY_HINT_RANGE, "0,1,0.001,or_lesser,or_greater"), "_set_anchor", "get_anchor", SIDE_RIGHT);
+	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "anchor_bottom", PROPERTY_HINT_RANGE, "0,1,0.001,or_lesser,or_greater"), "_set_anchor", "get_anchor", SIDE_BOTTOM);
 
-	ADD_GROUP("Margin", "margin_");
-	ADD_PROPERTYI(PropertyInfo(Variant::INT, "margin_left", PROPERTY_HINT_RANGE, "-4096,4096"), "set_margin", "get_margin", MARGIN_LEFT);
-	ADD_PROPERTYI(PropertyInfo(Variant::INT, "margin_top", PROPERTY_HINT_RANGE, "-4096,4096"), "set_margin", "get_margin", MARGIN_TOP);
-	ADD_PROPERTYI(PropertyInfo(Variant::INT, "margin_right", PROPERTY_HINT_RANGE, "-4096,4096"), "set_margin", "get_margin", MARGIN_RIGHT);
-	ADD_PROPERTYI(PropertyInfo(Variant::INT, "margin_bottom", PROPERTY_HINT_RANGE, "-4096,4096"), "set_margin", "get_margin", MARGIN_BOTTOM);
+	ADD_GROUP("Offset", "offset_");
+	ADD_PROPERTYI(PropertyInfo(Variant::INT, "offset_left", PROPERTY_HINT_RANGE, "-4096,4096"), "set_offset", "get_offset", SIDE_LEFT);
+	ADD_PROPERTYI(PropertyInfo(Variant::INT, "offset_top", PROPERTY_HINT_RANGE, "-4096,4096"), "set_offset", "get_offset", SIDE_TOP);
+	ADD_PROPERTYI(PropertyInfo(Variant::INT, "offset_right", PROPERTY_HINT_RANGE, "-4096,4096"), "set_offset", "get_offset", SIDE_RIGHT);
+	ADD_PROPERTYI(PropertyInfo(Variant::INT, "offset_bottom", PROPERTY_HINT_RANGE, "-4096,4096"), "set_offset", "get_offset", SIDE_BOTTOM);
 
 	ADD_GROUP("Grow Direction", "grow_");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "grow_horizontal", PROPERTY_HINT_ENUM, "Begin,End,Both"), "set_h_grow_direction", "get_h_grow_direction");
@@ -2922,10 +2922,10 @@ void Control::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::STRING, "hint_tooltip", PROPERTY_HINT_MULTILINE_TEXT), "set_tooltip", "_get_tooltip");
 
 	ADD_GROUP("Focus", "focus_");
-	ADD_PROPERTYI(PropertyInfo(Variant::NODE_PATH, "focus_neighbor_left", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Control"), "set_focus_neighbor", "get_focus_neighbor", MARGIN_LEFT);
-	ADD_PROPERTYI(PropertyInfo(Variant::NODE_PATH, "focus_neighbor_top", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Control"), "set_focus_neighbor", "get_focus_neighbor", MARGIN_TOP);
-	ADD_PROPERTYI(PropertyInfo(Variant::NODE_PATH, "focus_neighbor_right", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Control"), "set_focus_neighbor", "get_focus_neighbor", MARGIN_RIGHT);
-	ADD_PROPERTYI(PropertyInfo(Variant::NODE_PATH, "focus_neighbor_bottom", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Control"), "set_focus_neighbor", "get_focus_neighbor", MARGIN_BOTTOM);
+	ADD_PROPERTYI(PropertyInfo(Variant::NODE_PATH, "focus_neighbor_left", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Control"), "set_focus_neighbor", "get_focus_neighbor", SIDE_LEFT);
+	ADD_PROPERTYI(PropertyInfo(Variant::NODE_PATH, "focus_neighbor_top", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Control"), "set_focus_neighbor", "get_focus_neighbor", SIDE_TOP);
+	ADD_PROPERTYI(PropertyInfo(Variant::NODE_PATH, "focus_neighbor_right", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Control"), "set_focus_neighbor", "get_focus_neighbor", SIDE_RIGHT);
+	ADD_PROPERTYI(PropertyInfo(Variant::NODE_PATH, "focus_neighbor_bottom", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Control"), "set_focus_neighbor", "get_focus_neighbor", SIDE_BOTTOM);
 	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "focus_next", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Control"), "set_focus_next", "get_focus_next");
 	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "focus_previous", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Control"), "set_focus_previous", "get_focus_previous");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "focus_mode", PROPERTY_HINT_ENUM, "None,Click,All"), "set_focus_mode", "get_focus_mode");
diff --git a/scene/gui/control.h b/scene/gui/control.h
index 2241c242bb..ea336e3c59 100644
--- a/scene/gui/control.h
+++ b/scene/gui/control.h
@@ -171,7 +171,7 @@ private:
 		Size2 last_minimum_size;
 		bool updating_last_minimum_size = false;
 
-		float margin[4] = { 0.0, 0.0, 0.0, 0.0 };
+		float offset[4] = { 0.0, 0.0, 0.0, 0.0 };
 		float anchor[4] = { ANCHOR_BEGIN, ANCHOR_BEGIN, ANCHOR_BEGIN, ANCHOR_BEGIN };
 		FocusMode focus_mode = FOCUS_NONE;
 		GrowDirection h_grow = GROW_DIRECTION_END;
@@ -224,22 +224,22 @@ private:
 	Control *_find_control_at_pos(CanvasItem *p_node, const Point2 &p_pos, const Transform2D &p_xform, Transform2D &r_inv_xform);
 
 	void _window_find_focus_neighbor(const Vector2 &p_dir, Node *p_at, const Point2 *p_points, float p_min, float &r_closest_dist, Control **r_closest);
-	Control *_get_focus_neighbor(Margin p_margin, int p_count = 0);
+	Control *_get_focus_neighbor(Side p_side, int p_count = 0);
 
-	void _set_anchor(Margin p_margin, float p_anchor);
+	void _set_anchor(Side p_side, float p_anchor);
 	void _set_position(const Point2 &p_point);
 	void _set_global_position(const Point2 &p_point);
 	void _set_size(const Size2 &p_size);
 
 	void _theme_changed();
 
-	void _change_notify_margins();
+	void _change_notify_offsets();
 	void _update_minimum_size();
 
 	void _update_scroll();
 
-	void _compute_margins(Rect2 p_rect, const float p_anchors[4], float (&r_margins)[4]);
-	void _compute_anchors(Rect2 p_rect, const float p_margins[4], float (&r_anchors)[4]);
+	void _compute_offsets(Rect2 p_rect, const float p_anchors[4], float (&r_offsets)[4]);
+	void _compute_anchors(Rect2 p_rect, const float p_offsets[4], float (&r_anchors)[4]);
 
 	void _size_changed();
 	String _get_tooltip() const;
@@ -359,17 +359,17 @@ public:
 
 	/* POSITIONING */
 
-	void set_anchors_preset(LayoutPreset p_preset, bool p_keep_margins = true);
-	void set_margins_preset(LayoutPreset p_preset, LayoutPresetMode p_resize_mode = PRESET_MODE_MINSIZE, int p_margin = 0);
-	void set_anchors_and_margins_preset(LayoutPreset p_preset, LayoutPresetMode p_resize_mode = PRESET_MODE_MINSIZE, int p_margin = 0);
+	void set_anchors_preset(LayoutPreset p_preset, bool p_keep_offsets = true);
+	void set_offsets_preset(LayoutPreset p_preset, LayoutPresetMode p_resize_mode = PRESET_MODE_MINSIZE, int p_margin = 0);
+	void set_anchors_and_offsets_preset(LayoutPreset p_preset, LayoutPresetMode p_resize_mode = PRESET_MODE_MINSIZE, int p_margin = 0);
 
-	void set_anchor(Margin p_margin, float p_anchor, bool p_keep_margin = true, bool p_push_opposite_anchor = true);
-	float get_anchor(Margin p_margin) const;
+	void set_anchor(Side p_side, float p_anchor, bool p_keep_offset = true, bool p_push_opposite_anchor = true);
+	float get_anchor(Side p_side) const;
 
-	void set_margin(Margin p_margin, float p_value);
-	float get_margin(Margin p_margin) const;
+	void set_offset(Side p_side, float p_value);
+	float get_offset(Side p_side) const;
 
-	void set_anchor_and_margin(Margin p_margin, float p_anchor, float p_pos, bool p_push_opposite_anchor = true);
+	void set_anchor_and_offset(Side p_side, float p_anchor, float p_pos, bool p_push_opposite_anchor = true);
 
 	void set_begin(const Point2 &p_point); // helper
 	void set_end(const Point2 &p_point); // helper
@@ -377,13 +377,13 @@ public:
 	Point2 get_begin() const;
 	Point2 get_end() const;
 
-	void set_position(const Point2 &p_point, bool p_keep_margins = false);
-	void set_global_position(const Point2 &p_point, bool p_keep_margins = false);
+	void set_position(const Point2 &p_point, bool p_keep_offsets = false);
+	void set_global_position(const Point2 &p_point, bool p_keep_offsets = false);
 	Point2 get_position() const;
 	Point2 get_global_position() const;
 	Point2 get_screen_position() const;
 
-	void set_size(const Size2 &p_size, bool p_keep_margins = false);
+	void set_size(const Size2 &p_size, bool p_keep_offsets = false);
 	Size2 get_size() const;
 
 	Rect2 get_rect() const;
@@ -436,8 +436,8 @@ public:
 	Control *find_next_valid_focus() const;
 	Control *find_prev_valid_focus() const;
 
-	void set_focus_neighbor(Margin p_margin, const NodePath &p_neighbor);
-	NodePath get_focus_neighbor(Margin p_margin) const;
+	void set_focus_neighbor(Side p_side, const NodePath &p_neighbor);
+	NodePath get_focus_neighbor(Side p_side) const;
 
 	void set_focus_next(const NodePath &p_next);
 	NodePath get_focus_next() const;
diff --git a/scene/gui/dialogs.cpp b/scene/gui/dialogs.cpp
index 4e80498108..9f5f6c21c8 100644
--- a/scene/gui/dialogs.cpp
+++ b/scene/gui/dialogs.cpp
@@ -309,8 +309,8 @@ AcceptDialog::AcceptDialog() {
 	int button_margin = hbc->get_theme_constant("button_margin", "Dialogs");
 
 	label = memnew(Label);
-	label->set_anchor(MARGIN_RIGHT, Control::ANCHOR_END);
-	label->set_anchor(MARGIN_BOTTOM, Control::ANCHOR_END);
+	label->set_anchor(SIDE_RIGHT, Control::ANCHOR_END);
+	label->set_anchor(SIDE_BOTTOM, Control::ANCHOR_END);
 	label->set_begin(Point2(margin, margin));
 	label->set_end(Point2(-margin, -button_margin - 10));
 	add_child(label);
diff --git a/scene/gui/graph_edit.cpp b/scene/gui/graph_edit.cpp
index 2bcc1890fe..6c2d414ea9 100644
--- a/scene/gui/graph_edit.cpp
+++ b/scene/gui/graph_edit.cpp
@@ -276,7 +276,7 @@ void GraphEdit::_update_scroll_offset() {
 			continue;
 		}
 
-		Point2 pos = gn->get_offset() * zoom;
+		Point2 pos = gn->get_position_offset() * zoom;
 		pos -= Point2(h_scroll->get_value(), v_scroll->get_value());
 		gn->set_position(pos);
 		if (gn->get_scale() != Vector2(zoom, zoom)) {
@@ -306,7 +306,7 @@ void GraphEdit::_update_scroll() {
 		}
 
 		Rect2 r;
-		r.position = gn->get_offset() * zoom;
+		r.position = gn->get_position_offset() * zoom;
 		r.size = gn->get_size() * zoom;
 		screen = screen.merge(r);
 	}
@@ -337,8 +337,8 @@ void GraphEdit::_update_scroll() {
 	Size2 vmin = v_scroll->get_combined_minimum_size();
 
 	// Avoid scrollbar overlapping.
-	h_scroll->set_anchor_and_margin(MARGIN_RIGHT, ANCHOR_END, v_scroll->is_visible() ? -vmin.width : 0);
-	v_scroll->set_anchor_and_margin(MARGIN_BOTTOM, ANCHOR_END, h_scroll->is_visible() ? -hmin.height : 0);
+	h_scroll->set_anchor_and_offset(SIDE_RIGHT, ANCHOR_END, v_scroll->is_visible() ? -vmin.width : 0);
+	v_scroll->set_anchor_and_offset(SIDE_BOTTOM, ANCHOR_END, h_scroll->is_visible() ? -hmin.height : 0);
 
 	set_block_minimum_size_adjust(false);
 
@@ -429,15 +429,15 @@ void GraphEdit::_notification(int p_what) {
 		Size2 hmin = h_scroll->get_combined_minimum_size();
 		Size2 vmin = v_scroll->get_combined_minimum_size();
 
-		h_scroll->set_anchor_and_margin(MARGIN_LEFT, ANCHOR_BEGIN, 0);
-		h_scroll->set_anchor_and_margin(MARGIN_RIGHT, ANCHOR_END, 0);
-		h_scroll->set_anchor_and_margin(MARGIN_TOP, ANCHOR_END, -hmin.height);
-		h_scroll->set_anchor_and_margin(MARGIN_BOTTOM, ANCHOR_END, 0);
+		h_scroll->set_anchor_and_offset(SIDE_LEFT, ANCHOR_BEGIN, 0);
+		h_scroll->set_anchor_and_offset(SIDE_RIGHT, ANCHOR_END, 0);
+		h_scroll->set_anchor_and_offset(SIDE_TOP, ANCHOR_END, -hmin.height);
+		h_scroll->set_anchor_and_offset(SIDE_BOTTOM, ANCHOR_END, 0);
 
-		v_scroll->set_anchor_and_margin(MARGIN_LEFT, ANCHOR_END, -vmin.width);
-		v_scroll->set_anchor_and_margin(MARGIN_RIGHT, ANCHOR_END, 0);
-		v_scroll->set_anchor_and_margin(MARGIN_TOP, ANCHOR_BEGIN, 0);
-		v_scroll->set_anchor_and_margin(MARGIN_BOTTOM, ANCHOR_END, 0);
+		v_scroll->set_anchor_and_offset(SIDE_LEFT, ANCHOR_END, -vmin.width);
+		v_scroll->set_anchor_and_offset(SIDE_RIGHT, ANCHOR_END, 0);
+		v_scroll->set_anchor_and_offset(SIDE_TOP, ANCHOR_BEGIN, 0);
+		v_scroll->set_anchor_and_offset(SIDE_BOTTOM, ANCHOR_END, 0);
 	}
 	if (p_what == NOTIFICATION_DRAW) {
 		draw_style_box(get_theme_stylebox("bg"), Rect2(Point2(), get_size()));
@@ -851,9 +851,9 @@ void GraphEdit::_connections_layer_draw() {
 			continue;
 		}
 
-		Vector2 frompos = gfrom->get_connection_output_position(E->get().from_port) + gfrom->get_offset() * zoom;
+		Vector2 frompos = gfrom->get_connection_output_position(E->get().from_port) + gfrom->get_position_offset() * zoom;
 		Color color = gfrom->get_connection_output_color(E->get().from_port);
-		Vector2 topos = gto->get_connection_input_position(E->get().to_port) + gto->get_offset() * zoom;
+		Vector2 topos = gto->get_connection_input_position(E->get().to_port) + gto->get_position_offset() * zoom;
 		Color tocolor = gto->get_connection_input_color(E->get().to_port);
 
 		if (E->get().activity > 0) {
@@ -929,7 +929,7 @@ void GraphEdit::_minimap_draw() {
 			continue;
 		}
 
-		Vector2 node_position = minimap->_convert_from_graph_position(gn->get_offset() * zoom - graph_offset) + minimap_offset;
+		Vector2 node_position = minimap->_convert_from_graph_position(gn->get_position_offset() * zoom - graph_offset) + minimap_offset;
 		Vector2 node_size = minimap->_convert_from_graph_position(gn->get_size() * zoom);
 		Rect2 node_rect = Rect2(node_position, node_size);
 
@@ -952,7 +952,7 @@ void GraphEdit::_minimap_draw() {
 			continue;
 		}
 
-		Vector2 node_position = minimap->_convert_from_graph_position(gn->get_offset() * zoom - graph_offset) + minimap_offset;
+		Vector2 node_position = minimap->_convert_from_graph_position(gn->get_position_offset() * zoom - graph_offset) + minimap_offset;
 		Vector2 node_size = minimap->_convert_from_graph_position(gn->get_size() * zoom);
 		Rect2 node_rect = Rect2(node_position, node_size);
 
@@ -992,10 +992,10 @@ void GraphEdit::_minimap_draw() {
 			continue;
 		}
 
-		Vector2 from_slot_position = gfrom->get_offset() * zoom + gfrom->get_connection_output_position(E->get().from_port);
+		Vector2 from_slot_position = gfrom->get_position_offset() * zoom + gfrom->get_connection_output_position(E->get().from_port);
 		Vector2 from_position = minimap->_convert_from_graph_position(from_slot_position - graph_offset) + minimap_offset;
 		Color from_color = gfrom->get_connection_output_color(E->get().from_port);
-		Vector2 to_slot_position = gto->get_offset() * zoom + gto->get_connection_input_position(E->get().to_port);
+		Vector2 to_slot_position = gto->get_position_offset() * zoom + gto->get_connection_input_position(E->get().to_port);
 		Vector2 to_position = minimap->_convert_from_graph_position(to_slot_position - graph_offset) + minimap_offset;
 		Color to_color = gto->get_connection_input_color(E->get().to_port);
 
@@ -1054,7 +1054,7 @@ void GraphEdit::_gui_input(const Ref<InputEvent> &p_ev) {
 					pos = pos.snapped(Vector2(snap, snap));
 				}
 
-				gn->set_offset(pos);
+				gn->set_position_offset(pos);
 			}
 		}
 	}
@@ -1502,10 +1502,10 @@ void GraphEdit::set_minimap_size(Vector2 p_size) {
 	Vector2 minimap_size = minimap->get_size(); // The size might've been adjusted by the minimum size.
 
 	minimap->set_anchors_preset(Control::PRESET_BOTTOM_RIGHT);
-	minimap->set_margin(Margin::MARGIN_LEFT, -minimap_size.x - MINIMAP_OFFSET);
-	minimap->set_margin(Margin::MARGIN_TOP, -minimap_size.y - MINIMAP_OFFSET);
-	minimap->set_margin(Margin::MARGIN_RIGHT, -MINIMAP_OFFSET);
-	minimap->set_margin(Margin::MARGIN_BOTTOM, -MINIMAP_OFFSET);
+	minimap->set_offset(Side::SIDE_LEFT, -minimap_size.x - MINIMAP_OFFSET);
+	minimap->set_offset(Side::SIDE_TOP, -minimap_size.y - MINIMAP_OFFSET);
+	minimap->set_offset(Side::SIDE_RIGHT, -MINIMAP_OFFSET);
+	minimap->set_offset(Side::SIDE_BOTTOM, -MINIMAP_OFFSET);
 	minimap->update();
 }
 
@@ -1645,7 +1645,7 @@ GraphEdit::GraphEdit() {
 	top_layer = memnew(GraphEditFilter(this));
 	add_child(top_layer);
 	top_layer->set_mouse_filter(MOUSE_FILTER_PASS);
-	top_layer->set_anchors_and_margins_preset(Control::PRESET_WIDE);
+	top_layer->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
 	top_layer->connect("draw", callable_mp(this, &GraphEdit::_top_layer_draw));
 	top_layer->connect("gui_input", callable_mp(this, &GraphEdit::_top_layer_input));
 
@@ -1745,10 +1745,10 @@ GraphEdit::GraphEdit() {
 	minimap->set_custom_minimum_size(Vector2(50, 50));
 	minimap->set_size(minimap_size);
 	minimap->set_anchors_preset(Control::PRESET_BOTTOM_RIGHT);
-	minimap->set_margin(Margin::MARGIN_LEFT, -minimap_size.x - MINIMAP_OFFSET);
-	minimap->set_margin(Margin::MARGIN_TOP, -minimap_size.y - MINIMAP_OFFSET);
-	minimap->set_margin(Margin::MARGIN_RIGHT, -MINIMAP_OFFSET);
-	minimap->set_margin(Margin::MARGIN_BOTTOM, -MINIMAP_OFFSET);
+	minimap->set_offset(Side::SIDE_LEFT, -minimap_size.x - MINIMAP_OFFSET);
+	minimap->set_offset(Side::SIDE_TOP, -minimap_size.y - MINIMAP_OFFSET);
+	minimap->set_offset(Side::SIDE_RIGHT, -MINIMAP_OFFSET);
+	minimap->set_offset(Side::SIDE_BOTTOM, -MINIMAP_OFFSET);
 	minimap->connect("draw", callable_mp(this, &GraphEdit::_minimap_draw));
 
 	setting_scroll_ofs = false;
diff --git a/scene/gui/graph_node.cpp b/scene/gui/graph_node.cpp
index 4ce33ec8f2..eaee086b81 100644
--- a/scene/gui/graph_node.cpp
+++ b/scene/gui/graph_node.cpp
@@ -203,7 +203,7 @@ void GraphNode::_resort() {
 
 		Size2i size = c->get_combined_minimum_size();
 
-		Rect2 r(sb->get_margin(MARGIN_LEFT), sb->get_margin(MARGIN_TOP) + vofs, w, size.y);
+		Rect2 r(sb->get_margin(SIDE_LEFT), sb->get_margin(SIDE_TOP) + vofs, w, size.y);
 
 		fit_child_in_rect(c, r);
 		cache_y.push_back(vofs + size.y * 0.5);
@@ -224,7 +224,7 @@ bool GraphNode::has_point(const Point2 &p_point) const {
 			return true;
 		}
 
-		if (Rect2(0, 0, get_size().width, comment->get_margin(MARGIN_TOP)).has_point(p_point)) {
+		if (Rect2(0, 0, get_size().width, comment->get_margin(SIDE_TOP)).has_point(p_point)) {
 			return true;
 		}
 
@@ -261,7 +261,7 @@ void GraphNode::_notification(int p_what) {
 			Color title_color = get_theme_color("title_color");
 			Point2i icofs = -port->get_size() * 0.5;
 			int edgeofs = get_theme_constant("port_offset");
-			icofs.y += sb->get_margin(MARGIN_TOP);
+			icofs.y += sb->get_margin(SIDE_TOP);
 
 			draw_style_box(sb, Rect2(Point2(), get_size()));
 
@@ -284,9 +284,9 @@ void GraphNode::_notification(int p_what) {
 			}
 
 			title_buf->set_width(w);
-			title_buf->draw(get_canvas_item(), Point2(sb->get_margin(MARGIN_LEFT) + title_h_offset, -title_buf->get_size().y + title_offset), title_color);
+			title_buf->draw(get_canvas_item(), Point2(sb->get_margin(SIDE_LEFT) + title_h_offset, -title_buf->get_size().y + title_offset), title_color);
 			if (show_close) {
-				Vector2 cpos = Point2(w + sb->get_margin(MARGIN_LEFT) + close_h_offset, -close->get_height() + close_offset);
+				Vector2 cpos = Point2(w + sb->get_margin(SIDE_LEFT) + close_h_offset, -close->get_height() + close_offset);
 				draw_texture(close, cpos, close_color);
 				close_rect.position = cpos;
 				close_rect.size = close->get_size();
@@ -528,14 +528,14 @@ String GraphNode::get_language() const {
 	return language;
 }
 
-void GraphNode::set_offset(const Vector2 &p_offset) {
-	offset = p_offset;
-	emit_signal("offset_changed");
+void GraphNode::set_position_offset(const Vector2 &p_offset) {
+	position_offset = p_offset;
+	emit_signal("position_offset_changed");
 	update();
 }
 
-Vector2 GraphNode::get_offset() const {
-	return offset;
+Vector2 GraphNode::get_position_offset() const {
+	return position_offset;
 }
 
 void GraphNode::set_selected(bool p_selected) {
@@ -549,9 +549,9 @@ bool GraphNode::is_selected() {
 
 void GraphNode::set_drag(bool p_drag) {
 	if (p_drag) {
-		drag_from = get_offset();
+		drag_from = get_position_offset();
 	} else {
-		emit_signal("dragged", drag_from, get_offset()); //useful for undo/redo
+		emit_signal("dragged", drag_from, get_position_offset()); //useful for undo/redo
 	}
 }
 
@@ -590,7 +590,7 @@ void GraphNode::_connpos_update() {
 
 		Size2i size = c->get_combined_minimum_size();
 
-		int y = sb->get_margin(MARGIN_TOP) + vofs;
+		int y = sb->get_margin(SIDE_TOP) + vofs;
 		int h = size.y;
 
 		if (slot_info.has(idx)) {
@@ -787,8 +787,8 @@ void GraphNode::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_slot_type_right", "idx"), &GraphNode::get_slot_type_right);
 	ClassDB::bind_method(D_METHOD("get_slot_color_right", "idx"), &GraphNode::get_slot_color_right);
 
-	ClassDB::bind_method(D_METHOD("set_offset", "offset"), &GraphNode::set_offset);
-	ClassDB::bind_method(D_METHOD("get_offset"), &GraphNode::get_offset);
+	ClassDB::bind_method(D_METHOD("set_position_offset", "offset"), &GraphNode::set_position_offset);
+	ClassDB::bind_method(D_METHOD("get_position_offset"), &GraphNode::get_position_offset);
 
 	ClassDB::bind_method(D_METHOD("set_comment", "comment"), &GraphNode::set_comment);
 	ClassDB::bind_method(D_METHOD("is_comment"), &GraphNode::is_comment);
@@ -818,14 +818,14 @@ void GraphNode::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::STRING, "title"), "set_title", "get_title");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "text_direction", PROPERTY_HINT_ENUM, "Auto,LTR,RTL,Inherited"), "set_text_direction", "get_text_direction");
 	ADD_PROPERTY(PropertyInfo(Variant::STRING, "language"), "set_language", "get_language");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "offset"), "set_offset", "get_offset");
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "position_offset"), "set_position_offset", "get_position_offset");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "show_close"), "set_show_close_button", "is_close_button_visible");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "resizable"), "set_resizable", "is_resizable");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "selected"), "set_selected", "is_selected");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "comment"), "set_comment", "is_comment");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "overlay", PROPERTY_HINT_ENUM, "Disabled,Breakpoint,Position"), "set_overlay", "get_overlay");
 
-	ADD_SIGNAL(MethodInfo("offset_changed"));
+	ADD_SIGNAL(MethodInfo("position_offset_changed"));
 	ADD_SIGNAL(MethodInfo("dragged", PropertyInfo(Variant::VECTOR2, "from"), PropertyInfo(Variant::VECTOR2, "to")));
 	ADD_SIGNAL(MethodInfo("raise_request"));
 	ADD_SIGNAL(MethodInfo("close_request"));
diff --git a/scene/gui/graph_node.h b/scene/gui/graph_node.h
index 3cd7ae6e24..08ae0d465d 100644
--- a/scene/gui/graph_node.h
+++ b/scene/gui/graph_node.h
@@ -73,7 +73,7 @@ private:
 	TextDirection text_direction = TEXT_DIRECTION_AUTO;
 
 	bool show_close;
-	Vector2 offset;
+	Vector2 position_offset;
 	bool comment;
 	bool resizable;
 
@@ -142,8 +142,8 @@ public:
 	void set_language(const String &p_language);
 	String get_language() const;
 
-	void set_offset(const Vector2 &p_offset);
-	Vector2 get_offset() const;
+	void set_position_offset(const Vector2 &p_offset);
+	Vector2 get_position_offset() const;
 
 	void set_selected(bool p_selected);
 	bool is_selected();
diff --git a/scene/gui/item_list.cpp b/scene/gui/item_list.cpp
index 5be7804ac1..e0aef32e15 100644
--- a/scene/gui/item_list.cpp
+++ b/scene/gui/item_list.cpp
@@ -861,10 +861,10 @@ void ItemList::_notification(int p_what) {
 		Ref<StyleBox> bg = get_theme_stylebox("bg");
 
 		int mw = scroll_bar->get_minimum_size().x;
-		scroll_bar->set_anchor_and_margin(MARGIN_LEFT, ANCHOR_END, -mw);
-		scroll_bar->set_anchor_and_margin(MARGIN_RIGHT, ANCHOR_END, 0);
-		scroll_bar->set_anchor_and_margin(MARGIN_TOP, ANCHOR_BEGIN, bg->get_margin(MARGIN_TOP));
-		scroll_bar->set_anchor_and_margin(MARGIN_BOTTOM, ANCHOR_END, -bg->get_margin(MARGIN_BOTTOM));
+		scroll_bar->set_anchor_and_offset(SIDE_LEFT, ANCHOR_END, -mw);
+		scroll_bar->set_anchor_and_offset(SIDE_RIGHT, ANCHOR_END, 0);
+		scroll_bar->set_anchor_and_offset(SIDE_TOP, ANCHOR_BEGIN, bg->get_margin(SIDE_TOP));
+		scroll_bar->set_anchor_and_offset(SIDE_BOTTOM, ANCHOR_END, -bg->get_margin(SIDE_BOTTOM));
 
 		Size2 size = get_size();
 
@@ -1270,7 +1270,7 @@ void ItemList::_notification(int p_what) {
 			}
 
 			const int y = base_ofs.y + separators[i];
-			draw_line(Vector2(bg->get_margin(MARGIN_LEFT), y), Vector2(width, y), guide_color);
+			draw_line(Vector2(bg->get_margin(SIDE_LEFT), y), Vector2(width, y), guide_color);
 		}
 	}
 }
diff --git a/scene/gui/label.cpp b/scene/gui/label.cpp
index 566d77e3fd..d70f07c0a8 100644
--- a/scene/gui/label.cpp
+++ b/scene/gui/label.cpp
@@ -272,7 +272,7 @@ void Label::_notification(int p_what) {
 				case ALIGN_FILL:
 				case ALIGN_LEFT: {
 					if (rtl) {
-						ofs.x = int(size.width - style->get_margin(MARGIN_RIGHT) - TS->shaped_text_get_size(lines_rid[i]).x);
+						ofs.x = int(size.width - style->get_margin(SIDE_RIGHT) - TS->shaped_text_get_size(lines_rid[i]).x);
 					} else {
 						ofs.x = style->get_offset().x;
 					}
@@ -284,7 +284,7 @@ void Label::_notification(int p_what) {
 					if (rtl) {
 						ofs.x = style->get_offset().x;
 					} else {
-						ofs.x = int(size.width - style->get_margin(MARGIN_RIGHT) - TS->shaped_text_get_size(lines_rid[i]).x);
+						ofs.x = int(size.width - style->get_margin(SIDE_RIGHT) - TS->shaped_text_get_size(lines_rid[i]).x);
 					}
 				} break;
 			}
diff --git a/scene/gui/line_edit.cpp b/scene/gui/line_edit.cpp
index 9f8b944f4c..e623ba987f 100644
--- a/scene/gui/line_edit.cpp
+++ b/scene/gui/line_edit.cpp
@@ -743,7 +743,7 @@ void LineEdit::_notification(int p_what) {
 				case ALIGN_FILL:
 				case ALIGN_LEFT: {
 					if (rtl) {
-						x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(size.width - style->get_margin(MARGIN_RIGHT) - (text_width)));
+						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;
 					}
@@ -752,19 +752,19 @@ void LineEdit::_notification(int p_what) {
 					if (scroll_offset != 0) {
 						x_ofs = style->get_offset().x;
 					} else {
-						x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(size.width - (text_width)) / 2);
+						x_ofs = MAX(style->get_margin(SIDE_LEFT), int(size.width - (text_width)) / 2);
 					}
 				} break;
 				case ALIGN_RIGHT: {
 					if (rtl) {
 						x_ofs = style->get_offset().x;
 					} else {
-						x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(size.width - style->get_margin(MARGIN_RIGHT) - (text_width)));
+						x_ofs = MAX(style->get_margin(SIDE_LEFT), int(size.width - style->get_margin(SIDE_RIGHT) - (text_width)));
 					}
 				} break;
 			}
 
-			int ofs_max = width - style->get_margin(MARGIN_RIGHT);
+			int ofs_max = width - style->get_margin(SIDE_RIGHT);
 
 			int y_area = height - style->get_minimum_size().height;
 			int y_ofs = style->get_offset().y + (y_area - text_height) / 2;
@@ -791,14 +791,14 @@ void LineEdit::_notification(int p_what) {
 					}
 				}
 
-				r_icon->draw(ci, Point2(width - r_icon->get_width() - style->get_margin(MARGIN_RIGHT), height / 2 - r_icon->get_height() / 2), color_icon);
+				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 (scroll_offset == 0) {
-						x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(size.width - text_width - r_icon->get_width() - style->get_margin(MARGIN_RIGHT) * 2) / 2);
+						x_ofs = MAX(style->get_margin(SIDE_LEFT), int(size.width - text_width - r_icon->get_width() - style->get_margin(SIDE_RIGHT) * 2) / 2);
 					}
 				} else {
-					x_ofs = MAX(style->get_margin(MARGIN_LEFT), x_ofs - r_icon->get_width() - style->get_margin(MARGIN_RIGHT));
+					x_ofs = MAX(style->get_margin(SIDE_LEFT), x_ofs - r_icon->get_width() - style->get_margin(SIDE_RIGHT));
 				}
 
 				ofs_max -= r_icon->get_width();
@@ -1088,7 +1088,7 @@ void LineEdit::set_cursor_at_pixel_pos(int p_x) {
 		case ALIGN_FILL:
 		case ALIGN_LEFT: {
 			if (rtl) {
-				x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(get_size().width - style->get_margin(MARGIN_RIGHT) - (text_width)));
+				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;
 			}
@@ -1097,14 +1097,14 @@ void LineEdit::set_cursor_at_pixel_pos(int p_x) {
 			if (scroll_offset != 0) {
 				x_ofs = style->get_offset().x;
 			} else {
-				x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(get_size().width - (text_width)) / 2);
+				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - (text_width)) / 2);
 			}
 		} break;
 		case ALIGN_RIGHT: {
 			if (rtl) {
 				x_ofs = style->get_offset().x;
 			} else {
-				x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(get_size().width - style->get_margin(MARGIN_RIGHT) - (text_width)));
+				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - style->get_margin(SIDE_RIGHT) - (text_width)));
 			}
 		} break;
 	}
@@ -1115,10 +1115,10 @@ void LineEdit::set_cursor_at_pixel_pos(int p_x) {
 		Ref<Texture2D> r_icon = display_clear_icon ? Control::get_theme_icon("clear") : right_icon;
 		if (align == ALIGN_CENTER) {
 			if (scroll_offset == 0) {
-				x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(get_size().width - text_width - r_icon->get_width() - style->get_margin(MARGIN_RIGHT) * 2) / 2);
+				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);
 			}
 		} else {
-			x_ofs = MAX(style->get_margin(MARGIN_LEFT), x_ofs - r_icon->get_width() - style->get_margin(MARGIN_RIGHT));
+			x_ofs = MAX(style->get_margin(SIDE_LEFT), x_ofs - r_icon->get_width() - style->get_margin(SIDE_RIGHT));
 		}
 	}
 
@@ -1136,7 +1136,7 @@ Vector2i LineEdit::get_cursor_pixel_pos() {
 		case ALIGN_FILL:
 		case ALIGN_LEFT: {
 			if (rtl) {
-				x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(get_size().width - style->get_margin(MARGIN_RIGHT) - (text_width)));
+				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;
 			}
@@ -1145,14 +1145,14 @@ Vector2i LineEdit::get_cursor_pixel_pos() {
 			if (scroll_offset != 0) {
 				x_ofs = style->get_offset().x;
 			} else {
-				x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(get_size().width - (text_width)) / 2);
+				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - (text_width)) / 2);
 			}
 		} break;
 		case ALIGN_RIGHT: {
 			if (rtl) {
 				x_ofs = style->get_offset().x;
 			} else {
-				x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(get_size().width - style->get_margin(MARGIN_RIGHT) - (text_width)));
+				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - style->get_margin(SIDE_RIGHT) - (text_width)));
 			}
 		} break;
 	}
@@ -1163,10 +1163,10 @@ Vector2i LineEdit::get_cursor_pixel_pos() {
 		Ref<Texture2D> r_icon = display_clear_icon ? Control::get_theme_icon("clear") : right_icon;
 		if (align == ALIGN_CENTER) {
 			if (scroll_offset == 0) {
-				x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(get_size().width - text_width - r_icon->get_width() - style->get_margin(MARGIN_RIGHT) * 2) / 2);
+				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);
 			}
 		} else {
-			x_ofs = MAX(style->get_margin(MARGIN_LEFT), x_ofs - r_icon->get_width() - style->get_margin(MARGIN_RIGHT));
+			x_ofs = MAX(style->get_margin(SIDE_LEFT), x_ofs - r_icon->get_width() - style->get_margin(SIDE_RIGHT));
 		}
 	}
 
@@ -1460,7 +1460,7 @@ void LineEdit::set_cursor_position(int p_pos) {
 		case ALIGN_FILL:
 		case ALIGN_LEFT: {
 			if (rtl) {
-				x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(get_size().width - style->get_margin(MARGIN_RIGHT) - (text_width)));
+				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;
 			}
@@ -1469,29 +1469,29 @@ void LineEdit::set_cursor_position(int p_pos) {
 			if (scroll_offset != 0) {
 				x_ofs = style->get_offset().x;
 			} else {
-				x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(get_size().width - (text_width)) / 2);
+				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - (text_width)) / 2);
 			}
 		} break;
 		case ALIGN_RIGHT: {
 			if (rtl) {
 				x_ofs = style->get_offset().x;
 			} else {
-				x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(get_size().width - style->get_margin(MARGIN_RIGHT) - (text_width)));
+				x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - style->get_margin(SIDE_RIGHT) - (text_width)));
 			}
 		} break;
 	}
 
-	int ofs_max = get_size().width - style->get_margin(MARGIN_RIGHT);
+	int ofs_max = get_size().width - style->get_margin(SIDE_RIGHT);
 	bool using_placeholder = text.empty() && ime_text.empty();
 	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("clear") : right_icon;
 		if (align == ALIGN_CENTER) {
 			if (scroll_offset == 0) {
-				x_ofs = MAX(style->get_margin(MARGIN_LEFT), int(get_size().width - text_width - r_icon->get_width() - style->get_margin(MARGIN_RIGHT) * 2) / 2);
+				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);
 			}
 		} else {
-			x_ofs = MAX(style->get_margin(MARGIN_LEFT), x_ofs - r_icon->get_width() - style->get_margin(MARGIN_RIGHT));
+			x_ofs = MAX(style->get_margin(SIDE_LEFT), x_ofs - r_icon->get_width() - style->get_margin(SIDE_RIGHT));
 		}
 		ofs_max -= r_icon->get_width();
 	}
@@ -1994,7 +1994,7 @@ void LineEdit::_shape() {
 void LineEdit::_fit_to_width() {
 	if (align == ALIGN_FILL) {
 		Ref<StyleBox> style = get_theme_stylebox("normal");
-		int t_width = get_size().width - style->get_margin(MARGIN_RIGHT) - style->get_margin(MARGIN_LEFT);
+		int t_width = get_size().width - style->get_margin(SIDE_RIGHT) - style->get_margin(SIDE_LEFT);
 		bool using_placeholder = text.empty() && ime_text.empty();
 		bool display_clear_icon = !using_placeholder && is_editable() && clear_button_enabled;
 		if (right_icon.is_valid() || display_clear_icon) {
diff --git a/scene/gui/nine_patch_rect.cpp b/scene/gui/nine_patch_rect.cpp
index bc71ae94f5..72754f375a 100644
--- a/scene/gui/nine_patch_rect.cpp
+++ b/scene/gui/nine_patch_rect.cpp
@@ -44,12 +44,12 @@ void NinePatchRect::_notification(int p_what) {
 		texture->get_rect_region(rect, src_rect, rect, src_rect);
 
 		RID ci = get_canvas_item();
-		RS::get_singleton()->canvas_item_add_nine_patch(ci, rect, src_rect, texture->get_rid(), Vector2(margin[MARGIN_LEFT], margin[MARGIN_TOP]), Vector2(margin[MARGIN_RIGHT], margin[MARGIN_BOTTOM]), RS::NinePatchAxisMode(axis_h), RS::NinePatchAxisMode(axis_v), draw_center);
+		RS::get_singleton()->canvas_item_add_nine_patch(ci, rect, src_rect, texture->get_rid(), Vector2(margin[SIDE_LEFT], margin[SIDE_TOP]), Vector2(margin[SIDE_RIGHT], margin[SIDE_BOTTOM]), RS::NinePatchAxisMode(axis_h), RS::NinePatchAxisMode(axis_v), draw_center);
 	}
 }
 
 Size2 NinePatchRect::get_minimum_size() const {
-	return Size2(margin[MARGIN_LEFT] + margin[MARGIN_RIGHT], margin[MARGIN_TOP] + margin[MARGIN_BOTTOM]);
+	return Size2(margin[SIDE_LEFT] + margin[SIDE_RIGHT], margin[SIDE_TOP] + margin[SIDE_BOTTOM]);
 }
 
 void NinePatchRect::_bind_methods() {
@@ -73,10 +73,10 @@ void NinePatchRect::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::RECT2, "region_rect"), "set_region_rect", "get_region_rect");
 
 	ADD_GROUP("Patch Margin", "patch_margin_");
-	ADD_PROPERTYI(PropertyInfo(Variant::INT, "patch_margin_left", PROPERTY_HINT_RANGE, "0,16384,1"), "set_patch_margin", "get_patch_margin", MARGIN_LEFT);
-	ADD_PROPERTYI(PropertyInfo(Variant::INT, "patch_margin_top", PROPERTY_HINT_RANGE, "0,16384,1"), "set_patch_margin", "get_patch_margin", MARGIN_TOP);
-	ADD_PROPERTYI(PropertyInfo(Variant::INT, "patch_margin_right", PROPERTY_HINT_RANGE, "0,16384,1"), "set_patch_margin", "get_patch_margin", MARGIN_RIGHT);
-	ADD_PROPERTYI(PropertyInfo(Variant::INT, "patch_margin_bottom", PROPERTY_HINT_RANGE, "0,16384,1"), "set_patch_margin", "get_patch_margin", MARGIN_BOTTOM);
+	ADD_PROPERTYI(PropertyInfo(Variant::INT, "patch_margin_left", PROPERTY_HINT_RANGE, "0,16384,1"), "set_patch_margin", "get_patch_margin", SIDE_LEFT);
+	ADD_PROPERTYI(PropertyInfo(Variant::INT, "patch_margin_top", PROPERTY_HINT_RANGE, "0,16384,1"), "set_patch_margin", "get_patch_margin", SIDE_TOP);
+	ADD_PROPERTYI(PropertyInfo(Variant::INT, "patch_margin_right", PROPERTY_HINT_RANGE, "0,16384,1"), "set_patch_margin", "get_patch_margin", SIDE_RIGHT);
+	ADD_PROPERTYI(PropertyInfo(Variant::INT, "patch_margin_bottom", PROPERTY_HINT_RANGE, "0,16384,1"), "set_patch_margin", "get_patch_margin", SIDE_BOTTOM);
 	ADD_GROUP("Axis Stretch", "axis_stretch_");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "axis_stretch_horizontal", PROPERTY_HINT_ENUM, "Stretch,Tile,Tile Fit"), "set_h_axis_stretch_mode", "get_h_axis_stretch_mode");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "axis_stretch_vertical", PROPERTY_HINT_ENUM, "Stretch,Tile,Tile Fit"), "set_v_axis_stretch_mode", "get_v_axis_stretch_mode");
@@ -105,30 +105,30 @@ Ref<Texture2D> NinePatchRect::get_texture() const {
 	return texture;
 }
 
-void NinePatchRect::set_patch_margin(Margin p_margin, int p_size) {
-	ERR_FAIL_INDEX((int)p_margin, 4);
-	margin[p_margin] = p_size;
+void NinePatchRect::set_patch_margin(Side p_side, int p_size) {
+	ERR_FAIL_INDEX((int)p_side, 4);
+	margin[p_side] = p_size;
 	update();
 	minimum_size_changed();
-	switch (p_margin) {
-		case MARGIN_LEFT:
+	switch (p_side) {
+		case SIDE_LEFT:
 			_change_notify("patch_margin_left");
 			break;
-		case MARGIN_TOP:
+		case SIDE_TOP:
 			_change_notify("patch_margin_top");
 			break;
-		case MARGIN_RIGHT:
+		case SIDE_RIGHT:
 			_change_notify("patch_margin_right");
 			break;
-		case MARGIN_BOTTOM:
+		case SIDE_BOTTOM:
 			_change_notify("patch_margin_bottom");
 			break;
 	}
 }
 
-int NinePatchRect::get_patch_margin(Margin p_margin) const {
-	ERR_FAIL_INDEX_V((int)p_margin, 4, 0);
-	return margin[p_margin];
+int NinePatchRect::get_patch_margin(Side p_side) const {
+	ERR_FAIL_INDEX_V((int)p_side, 4, 0);
+	return margin[p_side];
 }
 
 void NinePatchRect::set_region_rect(const Rect2 &p_region_rect) {
@@ -174,10 +174,10 @@ NinePatchRect::AxisStretchMode NinePatchRect::get_v_axis_stretch_mode() const {
 }
 
 NinePatchRect::NinePatchRect() {
-	margin[MARGIN_LEFT] = 0;
-	margin[MARGIN_RIGHT] = 0;
-	margin[MARGIN_BOTTOM] = 0;
-	margin[MARGIN_TOP] = 0;
+	margin[SIDE_LEFT] = 0;
+	margin[SIDE_RIGHT] = 0;
+	margin[SIDE_BOTTOM] = 0;
+	margin[SIDE_TOP] = 0;
 
 	set_mouse_filter(MOUSE_FILTER_IGNORE);
 	draw_center = true;
diff --git a/scene/gui/nine_patch_rect.h b/scene/gui/nine_patch_rect.h
index a539ad43c0..91d24ada8f 100644
--- a/scene/gui/nine_patch_rect.h
+++ b/scene/gui/nine_patch_rect.h
@@ -59,8 +59,8 @@ public:
 	void set_texture(const Ref<Texture2D> &p_tex);
 	Ref<Texture2D> get_texture() const;
 
-	void set_patch_margin(Margin p_margin, int p_size);
-	int get_patch_margin(Margin p_margin) const;
+	void set_patch_margin(Side p_side, int p_size);
+	int get_patch_margin(Side p_side) const;
 
 	void set_region_rect(const Rect2 &p_region_rect);
 	Rect2 get_region_rect() const;
diff --git a/scene/gui/option_button.cpp b/scene/gui/option_button.cpp
index 902d2715d4..8fdd3db4e7 100644
--- a/scene/gui/option_button.cpp
+++ b/scene/gui/option_button.cpp
@@ -90,11 +90,11 @@ void OptionButton::_notification(int p_what) {
 		case NOTIFICATION_THEME_CHANGED: {
 			if (has_theme_icon("arrow")) {
 				if (is_layout_rtl()) {
-					_set_internal_margin(MARGIN_LEFT, Control::get_theme_icon("arrow")->get_width());
-					_set_internal_margin(MARGIN_RIGHT, 0.f);
+					_set_internal_margin(SIDE_LEFT, Control::get_theme_icon("arrow")->get_width());
+					_set_internal_margin(SIDE_RIGHT, 0.f);
 				} else {
-					_set_internal_margin(MARGIN_LEFT, 0.f);
-					_set_internal_margin(MARGIN_RIGHT, Control::get_theme_icon("arrow")->get_width());
+					_set_internal_margin(SIDE_LEFT, 0.f);
+					_set_internal_margin(SIDE_RIGHT, Control::get_theme_icon("arrow")->get_width());
 				}
 			}
 		} break;
@@ -341,11 +341,11 @@ OptionButton::OptionButton() {
 	set_text_align(ALIGN_LEFT);
 	if (is_layout_rtl()) {
 		if (has_theme_icon("arrow")) {
-			_set_internal_margin(MARGIN_LEFT, Control::get_theme_icon("arrow")->get_width());
+			_set_internal_margin(SIDE_LEFT, Control::get_theme_icon("arrow")->get_width());
 		}
 	} else {
 		if (has_theme_icon("arrow")) {
-			_set_internal_margin(MARGIN_RIGHT, Control::get_theme_icon("arrow")->get_width());
+			_set_internal_margin(SIDE_RIGHT, Control::get_theme_icon("arrow")->get_width());
 		}
 	}
 	set_action_mode(ACTION_MODE_BUTTON_PRESS);
diff --git a/scene/gui/popup_menu.cpp b/scene/gui/popup_menu.cpp
index 07f03ad40e..e1a324efb3 100644
--- a/scene/gui/popup_menu.cpp
+++ b/scene/gui/popup_menu.cpp
@@ -571,9 +571,9 @@ void PopupMenu::_draw_items() {
 		// Submenu arrow on right hand side
 		if (items[i].submenu != "") {
 			if (rtl) {
-				submenu->draw(ci, Point2(scroll_width + style->get_margin(MARGIN_LEFT), item_ofs.y + Math::floor(h - submenu->get_height()) / 2), icon_color);
+				submenu->draw(ci, Point2(scroll_width + style->get_margin(SIDE_LEFT), item_ofs.y + Math::floor(h - submenu->get_height()) / 2), icon_color);
 			} else {
-				submenu->draw(ci, Point2(display_width - style->get_margin(MARGIN_RIGHT) - submenu->get_width(), item_ofs.y + Math::floor(h - submenu->get_height()) / 2), icon_color);
+				submenu->draw(ci, Point2(display_width - style->get_margin(SIDE_RIGHT) - submenu->get_width(), item_ofs.y + Math::floor(h - submenu->get_height()) / 2), icon_color);
 			}
 		}
 
@@ -595,9 +595,9 @@ void PopupMenu::_draw_items() {
 		// Accelerator / Shortcut
 		if (items[i].accel || (items[i].shortcut.is_valid() && items[i].shortcut->is_valid())) {
 			if (rtl) {
-				item_ofs.x = scroll_width + style->get_margin(MARGIN_LEFT);
+				item_ofs.x = scroll_width + style->get_margin(SIDE_LEFT);
 			} else {
-				item_ofs.x = display_width - style->get_margin(MARGIN_RIGHT) - items[i].accel_text_buf->get_size().x;
+				item_ofs.x = display_width - style->get_margin(SIDE_RIGHT) - items[i].accel_text_buf->get_size().x;
 			}
 			items[i].accel_text_buf->draw(ci, item_ofs + Point2(0, Math::floor((h - items[i].text_buf->get_size().y) / 2.0)), i == mouse_over ? font_color_hover : font_color_accel);
 		}
@@ -745,10 +745,10 @@ void PopupMenu::_notification(int p_what) {
 
 				// Set margin on the margin container
 				Ref<StyleBox> panel_style = get_theme_stylebox("panel");
-				margin_container->add_theme_constant_override("margin_top", panel_style->get_margin(Margin::MARGIN_TOP));
-				margin_container->add_theme_constant_override("margin_bottom", panel_style->get_margin(Margin::MARGIN_BOTTOM));
-				margin_container->add_theme_constant_override("margin_left", panel_style->get_margin(Margin::MARGIN_LEFT));
-				margin_container->add_theme_constant_override("margin_right", panel_style->get_margin(Margin::MARGIN_RIGHT));
+				margin_container->add_theme_constant_override("margin_top", panel_style->get_margin(Side::SIDE_TOP));
+				margin_container->add_theme_constant_override("margin_bottom", panel_style->get_margin(Side::SIDE_BOTTOM));
+				margin_container->add_theme_constant_override("margin_left", panel_style->get_margin(Side::SIDE_LEFT));
+				margin_container->add_theme_constant_override("margin_right", panel_style->get_margin(Side::SIDE_RIGHT));
 			}
 		} break;
 	}
@@ -1643,7 +1643,7 @@ void PopupMenu::popup(const Rect2 &p_bounds) {
 PopupMenu::PopupMenu() {
 	// Margin Container
 	margin_container = memnew(MarginContainer);
-	margin_container->set_anchors_and_margins_preset(Control::PRESET_WIDE);
+	margin_container->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
 	add_child(margin_container);
 	margin_container->connect("draw", callable_mp(this, &PopupMenu::_draw_background));
 
@@ -1655,7 +1655,7 @@ PopupMenu::PopupMenu() {
 	// The control which will display the items
 	control = memnew(Control);
 	control->set_clip_contents(false);
-	control->set_anchors_and_margins_preset(Control::PRESET_WIDE);
+	control->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
 	control->set_h_size_flags(Control::SIZE_EXPAND_FILL);
 	control->set_v_size_flags(Control::SIZE_EXPAND_FILL);
 	scroll_container->add_child(control);
diff --git a/scene/gui/rich_text_label.cpp b/scene/gui/rich_text_label.cpp
index 244d90ca6b..40138e458b 100644
--- a/scene/gui/rich_text_label.cpp
+++ b/scene/gui/rich_text_label.cpp
@@ -1250,7 +1250,7 @@ void RichTextLabel::_update_scroll() {
 			scroll_visible = true;
 			scroll_w = vscroll->get_combined_minimum_size().width;
 			vscroll->show();
-			vscroll->set_anchor_and_margin(MARGIN_LEFT, ANCHOR_END, -scroll_w);
+			vscroll->set_anchor_and_offset(SIDE_LEFT, ANCHOR_END, -scroll_w);
 		} else {
 			scroll_visible = false;
 			scroll_w = 0;
@@ -3956,9 +3956,9 @@ RichTextLabel::RichTextLabel() {
 	add_child(vscroll);
 	vscroll->set_drag_node(String(".."));
 	vscroll->set_step(1);
-	vscroll->set_anchor_and_margin(MARGIN_TOP, ANCHOR_BEGIN, 0);
-	vscroll->set_anchor_and_margin(MARGIN_BOTTOM, ANCHOR_END, 0);
-	vscroll->set_anchor_and_margin(MARGIN_RIGHT, ANCHOR_END, 0);
+	vscroll->set_anchor_and_offset(SIDE_TOP, ANCHOR_BEGIN, 0);
+	vscroll->set_anchor_and_offset(SIDE_BOTTOM, ANCHOR_END, 0);
+	vscroll->set_anchor_and_offset(SIDE_RIGHT, ANCHOR_END, 0);
 	vscroll->connect("value_changed", callable_mp(this, &RichTextLabel::_scroll_changed));
 	vscroll->set_step(1);
 	vscroll->hide();
diff --git a/scene/gui/scroll_bar.cpp b/scene/gui/scroll_bar.cpp
index 70de63fd40..1a4d19eab3 100644
--- a/scene/gui/scroll_bar.cpp
+++ b/scene/gui/scroll_bar.cpp
@@ -259,11 +259,11 @@ void ScrollBar::_notification(int p_what) {
 			grabber_rect.size.width = get_grabber_size();
 			grabber_rect.size.height = get_size().height;
 			grabber_rect.position.y = 0;
-			grabber_rect.position.x = get_grabber_offset() + decr->get_width() + bg->get_margin(MARGIN_LEFT);
+			grabber_rect.position.x = get_grabber_offset() + decr->get_width() + bg->get_margin(SIDE_LEFT);
 		} else {
 			grabber_rect.size.width = get_size().width;
 			grabber_rect.size.height = get_grabber_size();
-			grabber_rect.position.y = get_grabber_offset() + decr->get_height() + bg->get_margin(MARGIN_TOP);
+			grabber_rect.position.y = get_grabber_offset() + decr->get_height() + bg->get_margin(SIDE_TOP);
 			grabber_rect.position.x = 0;
 		}
 
@@ -437,12 +437,12 @@ double ScrollBar::get_area_offset() const {
 	double ofs = 0;
 
 	if (orientation == VERTICAL) {
-		ofs += get_theme_stylebox("hscroll")->get_margin(MARGIN_TOP);
+		ofs += get_theme_stylebox("hscroll")->get_margin(SIDE_TOP);
 		ofs += get_theme_icon("decrement")->get_height();
 	}
 
 	if (orientation == HORIZONTAL) {
-		ofs += get_theme_stylebox("hscroll")->get_margin(MARGIN_LEFT);
+		ofs += get_theme_stylebox("hscroll")->get_margin(SIDE_LEFT);
 		ofs += get_theme_icon("decrement")->get_width();
 	}
 
diff --git a/scene/gui/scroll_container.cpp b/scene/gui/scroll_container.cpp
index 3a54ac7443..65f1084dc2 100644
--- a/scene/gui/scroll_container.cpp
+++ b/scene/gui/scroll_container.cpp
@@ -220,15 +220,15 @@ void ScrollContainer::_update_scrollbar_position() {
 	Size2 hmin = h_scroll->get_combined_minimum_size();
 	Size2 vmin = v_scroll->get_combined_minimum_size();
 
-	h_scroll->set_anchor_and_margin(MARGIN_LEFT, ANCHOR_BEGIN, 0);
-	h_scroll->set_anchor_and_margin(MARGIN_RIGHT, ANCHOR_END, 0);
-	h_scroll->set_anchor_and_margin(MARGIN_TOP, ANCHOR_END, -hmin.height);
-	h_scroll->set_anchor_and_margin(MARGIN_BOTTOM, ANCHOR_END, 0);
+	h_scroll->set_anchor_and_offset(SIDE_LEFT, ANCHOR_BEGIN, 0);
+	h_scroll->set_anchor_and_offset(SIDE_RIGHT, ANCHOR_END, 0);
+	h_scroll->set_anchor_and_offset(SIDE_TOP, ANCHOR_END, -hmin.height);
+	h_scroll->set_anchor_and_offset(SIDE_BOTTOM, ANCHOR_END, 0);
 
-	v_scroll->set_anchor_and_margin(MARGIN_LEFT, ANCHOR_END, -vmin.width);
-	v_scroll->set_anchor_and_margin(MARGIN_RIGHT, ANCHOR_END, 0);
-	v_scroll->set_anchor_and_margin(MARGIN_TOP, ANCHOR_BEGIN, 0);
-	v_scroll->set_anchor_and_margin(MARGIN_BOTTOM, ANCHOR_END, 0);
+	v_scroll->set_anchor_and_offset(SIDE_LEFT, ANCHOR_END, -vmin.width);
+	v_scroll->set_anchor_and_offset(SIDE_RIGHT, ANCHOR_END, 0);
+	v_scroll->set_anchor_and_offset(SIDE_TOP, ANCHOR_BEGIN, 0);
+	v_scroll->set_anchor_and_offset(SIDE_BOTTOM, ANCHOR_END, 0);
 
 	h_scroll->raise();
 	v_scroll->raise();
@@ -462,8 +462,8 @@ void ScrollContainer::update_scrollbars() {
 	}
 
 	// Avoid scrollbar overlapping.
-	h_scroll->set_anchor_and_margin(MARGIN_RIGHT, ANCHOR_END, hide_scroll_v ? 0 : -vmin.width);
-	v_scroll->set_anchor_and_margin(MARGIN_BOTTOM, ANCHOR_END, hide_scroll_h ? 0 : -hmin.height);
+	h_scroll->set_anchor_and_offset(SIDE_RIGHT, ANCHOR_END, hide_scroll_v ? 0 : -vmin.width);
+	v_scroll->set_anchor_and_offset(SIDE_BOTTOM, ANCHOR_END, hide_scroll_h ? 0 : -hmin.height);
 }
 
 void ScrollContainer::_scroll_moved(float) {
diff --git a/scene/gui/spin_box.cpp b/scene/gui/spin_box.cpp
index 46b24efed5..a4de4a0408 100644
--- a/scene/gui/spin_box.cpp
+++ b/scene/gui/spin_box.cpp
@@ -173,8 +173,8 @@ void SpinBox::_line_edit_focus_exit() {
 inline void SpinBox::_adjust_width_for_icon(const Ref<Texture2D> &icon) {
 	int w = icon->get_width();
 	if ((w != last_w)) {
-		line_edit->set_margin(MARGIN_LEFT, 0);
-		line_edit->set_margin(MARGIN_RIGHT, -w);
+		line_edit->set_offset(SIDE_LEFT, 0);
+		line_edit->set_offset(SIDE_RIGHT, -w);
 		last_w = w;
 	}
 }
@@ -272,7 +272,7 @@ SpinBox::SpinBox() {
 	line_edit = memnew(LineEdit);
 	add_child(line_edit);
 
-	line_edit->set_anchors_and_margins_preset(Control::PRESET_WIDE);
+	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);
 
diff --git a/scene/gui/tab_container.cpp b/scene/gui/tab_container.cpp
index 809b4ffd64..ddb2b1fe47 100644
--- a/scene/gui/tab_container.cpp
+++ b/scene/gui/tab_container.cpp
@@ -547,8 +547,8 @@ void TabContainer::_draw_tab(Ref<StyleBox> &p_tab_style, Color &p_font_color, in
 	Control *control = Object::cast_to<Control>(tabs[p_index]);
 	String text = control->has_meta("_tab_name") ? String(tr(String(control->get_meta("_tab_name")))) : String(tr(control->get_name()));
 
-	int x_content = tab_rect.position.x + p_tab_style->get_margin(MARGIN_LEFT);
-	int top_margin = p_tab_style->get_margin(MARGIN_TOP);
+	int x_content = tab_rect.position.x + p_tab_style->get_margin(SIDE_LEFT);
+	int top_margin = p_tab_style->get_margin(SIDE_TOP);
 	int y_center = top_margin + (tab_rect.size.y - p_tab_style->get_minimum_size().y) / 2;
 
 	// Draw the tab icon.
@@ -607,14 +607,14 @@ void TabContainer::_repaint() {
 		Control *c = tabs[i];
 		if (i == current) {
 			c->show();
-			c->set_anchors_and_margins_preset(Control::PRESET_WIDE);
+			c->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
 			if (tabs_visible) {
-				c->set_margin(MARGIN_TOP, _get_top_margin());
+				c->set_offset(SIDE_TOP, _get_top_margin());
 			}
-			c->set_margin(Margin(MARGIN_TOP), c->get_margin(Margin(MARGIN_TOP)) + sb->get_margin(Margin(MARGIN_TOP)));
-			c->set_margin(Margin(MARGIN_LEFT), c->get_margin(Margin(MARGIN_LEFT)) + sb->get_margin(Margin(MARGIN_LEFT)));
-			c->set_margin(Margin(MARGIN_RIGHT), c->get_margin(Margin(MARGIN_RIGHT)) - sb->get_margin(Margin(MARGIN_RIGHT)));
-			c->set_margin(Margin(MARGIN_BOTTOM), c->get_margin(Margin(MARGIN_BOTTOM)) - sb->get_margin(Margin(MARGIN_BOTTOM)));
+			c->set_offset(Side(SIDE_TOP), c->get_offset(Side(SIDE_TOP)) + sb->get_margin(Side(SIDE_TOP)));
+			c->set_offset(Side(SIDE_LEFT), c->get_offset(Side(SIDE_LEFT)) + sb->get_margin(Side(SIDE_LEFT)));
+			c->set_offset(Side(SIDE_RIGHT), c->get_offset(Side(SIDE_RIGHT)) - sb->get_margin(Side(SIDE_RIGHT)));
+			c->set_offset(Side(SIDE_BOTTOM), c->get_offset(Side(SIDE_BOTTOM)) - sb->get_margin(Side(SIDE_BOTTOM)));
 
 		} else {
 			c->hide();
@@ -712,15 +712,15 @@ void TabContainer::add_child_notify(Node *p_child) {
 		current = 0;
 		previous = 0;
 	}
-	c->set_anchors_and_margins_preset(Control::PRESET_WIDE);
+	c->set_anchors_and_offsets_preset(Control::PRESET_WIDE);
 	if (tabs_visible) {
-		c->set_margin(MARGIN_TOP, _get_top_margin());
+		c->set_offset(SIDE_TOP, _get_top_margin());
 	}
 	Ref<StyleBox> sb = get_theme_stylebox("panel");
-	c->set_margin(Margin(MARGIN_TOP), c->get_margin(Margin(MARGIN_TOP)) + sb->get_margin(Margin(MARGIN_TOP)));
-	c->set_margin(Margin(MARGIN_LEFT), c->get_margin(Margin(MARGIN_LEFT)) + sb->get_margin(Margin(MARGIN_LEFT)));
-	c->set_margin(Margin(MARGIN_RIGHT), c->get_margin(Margin(MARGIN_RIGHT)) - sb->get_margin(Margin(MARGIN_RIGHT)));
-	c->set_margin(Margin(MARGIN_BOTTOM), c->get_margin(Margin(MARGIN_BOTTOM)) - sb->get_margin(Margin(MARGIN_BOTTOM)));
+	c->set_offset(Side(SIDE_TOP), c->get_offset(Side(SIDE_TOP)) + sb->get_margin(Side(SIDE_TOP)));
+	c->set_offset(Side(SIDE_LEFT), c->get_offset(Side(SIDE_LEFT)) + sb->get_margin(Side(SIDE_LEFT)));
+	c->set_offset(Side(SIDE_RIGHT), c->get_offset(Side(SIDE_RIGHT)) - sb->get_margin(Side(SIDE_RIGHT)));
+	c->set_offset(Side(SIDE_BOTTOM), c->get_offset(Side(SIDE_BOTTOM)) - sb->get_margin(Side(SIDE_BOTTOM)));
 	update();
 	p_child->connect("renamed", callable_mp(this, &TabContainer::_child_renamed_callback));
 	if (first && is_inside_tree()) {
@@ -982,9 +982,9 @@ void TabContainer::set_tabs_visible(bool p_visible) {
 	for (int i = 0; i < tabs.size(); i++) {
 		Control *c = tabs[i];
 		if (p_visible) {
-			c->set_margin(MARGIN_TOP, _get_top_margin());
+			c->set_offset(SIDE_TOP, _get_top_margin());
 		} else {
-			c->set_margin(MARGIN_TOP, 0);
+			c->set_offset(SIDE_TOP, 0);
 		}
 	}
 
diff --git a/scene/gui/tabs.cpp b/scene/gui/tabs.cpp
index 5b26428e45..d332a5cbc6 100644
--- a/scene/gui/tabs.cpp
+++ b/scene/gui/tabs.cpp
@@ -341,15 +341,15 @@ void Tabs::_notification(int p_what) {
 				}
 				sb->draw(ci, sb_rect);
 
-				w += sb->get_margin(MARGIN_LEFT);
+				w += sb->get_margin(SIDE_LEFT);
 
 				Size2i sb_ms = sb->get_minimum_size();
 				Ref<Texture2D> icon = tabs[i].icon;
 				if (icon.is_valid()) {
 					if (rtl) {
-						icon->draw(ci, Point2i(size.width - w - icon->get_width(), sb->get_margin(MARGIN_TOP) + ((sb_rect.size.y - sb_ms.y) - icon->get_height()) / 2));
+						icon->draw(ci, Point2i(size.width - w - icon->get_width(), sb->get_margin(SIDE_TOP) + ((sb_rect.size.y - sb_ms.y) - icon->get_height()) / 2));
 					} else {
-						icon->draw(ci, Point2i(w, sb->get_margin(MARGIN_TOP) + ((sb_rect.size.y - sb_ms.y) - icon->get_height()) / 2));
+						icon->draw(ci, Point2i(w, sb->get_margin(SIDE_TOP) + ((sb_rect.size.y - sb_ms.y) - icon->get_height()) / 2));
 					}
 					if (tabs[i].text != "") {
 						w += icon->get_width() + get_theme_constant("hseparation");
@@ -357,9 +357,9 @@ void Tabs::_notification(int p_what) {
 				}
 
 				if (rtl) {
-					tabs[i].text_buf->draw(ci, Point2i(size.width - w - tabs[i].text_buf->get_size().x, sb->get_margin(MARGIN_TOP) + ((sb_rect.size.y - sb_ms.y) - tabs[i].text_buf->get_size().y) / 2), col);
+					tabs[i].text_buf->draw(ci, Point2i(size.width - w - tabs[i].text_buf->get_size().x, sb->get_margin(SIDE_TOP) + ((sb_rect.size.y - sb_ms.y) - tabs[i].text_buf->get_size().y) / 2), col);
 				} else {
-					tabs[i].text_buf->draw(ci, Point2i(w, sb->get_margin(MARGIN_TOP) + ((sb_rect.size.y - sb_ms.y) - tabs[i].text_buf->get_size().y) / 2), col);
+					tabs[i].text_buf->draw(ci, Point2i(w, sb->get_margin(SIDE_TOP) + ((sb_rect.size.y - sb_ms.y) - tabs[i].text_buf->get_size().y) / 2), col);
 				}
 
 				w += tabs[i].size_text;
@@ -377,7 +377,7 @@ void Tabs::_notification(int p_what) {
 					} else {
 						rb_rect.position.x = w;
 					}
-					rb_rect.position.y = sb->get_margin(MARGIN_TOP) + ((sb_rect.size.y - sb_ms.y) - (rb_rect.size.y)) / 2;
+					rb_rect.position.y = sb->get_margin(SIDE_TOP) + ((sb_rect.size.y - sb_ms.y) - (rb_rect.size.y)) / 2;
 
 					if (rb_hover == i) {
 						if (rb_pressing) {
@@ -388,9 +388,9 @@ void Tabs::_notification(int p_what) {
 					}
 
 					if (rtl) {
-						rb->draw(ci, Point2i(size.width - w - rb_rect.size.x + style->get_margin(MARGIN_LEFT), rb_rect.position.y + style->get_margin(MARGIN_TOP)));
+						rb->draw(ci, Point2i(size.width - w - rb_rect.size.x + style->get_margin(SIDE_LEFT), rb_rect.position.y + style->get_margin(SIDE_TOP)));
 					} else {
-						rb->draw(ci, Point2i(w + style->get_margin(MARGIN_LEFT), rb_rect.position.y + style->get_margin(MARGIN_TOP)));
+						rb->draw(ci, Point2i(w + style->get_margin(SIDE_LEFT), rb_rect.position.y + style->get_margin(SIDE_TOP)));
 					}
 					w += rb->get_width();
 					tabs.write[i].rb_rect = rb_rect;
@@ -409,7 +409,7 @@ void Tabs::_notification(int p_what) {
 					} else {
 						cb_rect.position.x = w;
 					}
-					cb_rect.position.y = sb->get_margin(MARGIN_TOP) + ((sb_rect.size.y - sb_ms.y) - (cb_rect.size.y)) / 2;
+					cb_rect.position.y = sb->get_margin(SIDE_TOP) + ((sb_rect.size.y - sb_ms.y) - (cb_rect.size.y)) / 2;
 
 					if (!tabs[i].disabled && cb_hover == i) {
 						if (cb_pressing) {
@@ -420,15 +420,15 @@ void Tabs::_notification(int p_what) {
 					}
 
 					if (rtl) {
-						cb->draw(ci, Point2i(size.width - w - cb_rect.size.x + style->get_margin(MARGIN_LEFT), cb_rect.position.y + style->get_margin(MARGIN_TOP)));
+						cb->draw(ci, Point2i(size.width - w - cb_rect.size.x + style->get_margin(SIDE_LEFT), cb_rect.position.y + style->get_margin(SIDE_TOP)));
 					} else {
-						cb->draw(ci, Point2i(w + style->get_margin(MARGIN_LEFT), cb_rect.position.y + style->get_margin(MARGIN_TOP)));
+						cb->draw(ci, Point2i(w + style->get_margin(SIDE_LEFT), cb_rect.position.y + style->get_margin(SIDE_TOP)));
 					}
 					w += cb->get_width();
 					tabs.write[i].cb_rect = cb_rect;
 				}
 
-				w += sb->get_margin(MARGIN_RIGHT);
+				w += sb->get_margin(SIDE_RIGHT);
 			}
 
 			if (offset > 0 || missing_right) {
@@ -691,7 +691,7 @@ void Tabs::_update_cache() {
 		int slen = tabs[i].size_text;
 		if (min_width > 0 && mw > limit && i != current) {
 			if (lsize > m_width) {
-				slen = m_width - (sb->get_margin(MARGIN_LEFT) + sb->get_margin(MARGIN_RIGHT));
+				slen = m_width - (sb->get_margin(SIDE_LEFT) + sb->get_margin(SIDE_RIGHT));
 				if (tabs[i].icon.is_valid()) {
 					slen -= tabs[i].icon->get_width();
 					slen -= get_theme_constant("hseparation");
diff --git a/scene/gui/text_edit.cpp b/scene/gui/text_edit.cpp
index f3569f9ce3..971d374667 100644
--- a/scene/gui/text_edit.cpp
+++ b/scene/gui/text_edit.cpp
@@ -296,8 +296,8 @@ void TextEdit::_update_scrollbars() {
 	Size2 hmin = h_scroll->get_combined_minimum_size();
 	Size2 vmin = v_scroll->get_combined_minimum_size();
 
-	v_scroll->set_begin(Point2(size.width - vmin.width, cache.style_normal->get_margin(MARGIN_TOP)));
-	v_scroll->set_end(Point2(size.width, size.height - cache.style_normal->get_margin(MARGIN_TOP) - cache.style_normal->get_margin(MARGIN_BOTTOM)));
+	v_scroll->set_begin(Point2(size.width - vmin.width, cache.style_normal->get_margin(SIDE_TOP)));
+	v_scroll->set_end(Point2(size.width, size.height - cache.style_normal->get_margin(SIDE_TOP) - cache.style_normal->get_margin(SIDE_BOTTOM)));
 
 	h_scroll->set_begin(Point2(0, size.height - hmin.height));
 	h_scroll->set_end(Point2(size.width - vmin.width, size.height));
@@ -489,7 +489,7 @@ void TextEdit::_update_selection_mode_line() {
 void TextEdit::_update_minimap_click() {
 	Point2 mp = _get_local_mouse_pos();
 
-	int xmargin_end = get_size().width - cache.style_normal->get_margin(MARGIN_RIGHT);
+	int xmargin_end = get_size().width - cache.style_normal->get_margin(SIDE_RIGHT);
 	if (!dragging_minimap && (mp.x < xmargin_end - minimap_width || mp.y > xmargin_end)) {
 		minimap_clicked = false;
 		return;
@@ -622,9 +622,9 @@ void TextEdit::_notification(int p_what) {
 
 			RID ci = get_canvas_item();
 			RenderingServer::get_singleton()->canvas_item_set_clip(get_canvas_item(), true);
-			int xmargin_beg = cache.style_normal->get_margin(MARGIN_LEFT) + gutters_width + gutter_padding;
+			int xmargin_beg = cache.style_normal->get_margin(SIDE_LEFT) + gutters_width + gutter_padding;
 
-			int xmargin_end = size.width - cache.style_normal->get_margin(MARGIN_RIGHT) - cache.minimap_width;
+			int xmargin_end = size.width - cache.style_normal->get_margin(SIDE_RIGHT) - cache.minimap_width;
 			// Let's do it easy for now.
 			cache.style_normal->draw(ci, Rect2(Point2(), size));
 			if (readonly) {
@@ -1071,7 +1071,7 @@ void TextEdit::_notification(int p_what) {
 					if (line_wrap_index == 0) {
 						// Only do these if we are on the first wrapped part of a line.
 
-						int gutter_offset = cache.style_normal->get_margin(MARGIN_LEFT);
+						int gutter_offset = cache.style_normal->get_margin(SIDE_LEFT);
 						for (int g = 0; g < gutters.size(); g++) {
 							const GutterInfo gutter = gutters[g];
 
@@ -2035,7 +2035,7 @@ int TextEdit::_calculate_spaces_till_next_right_indent(int column) {
 
 void TextEdit::_get_mouse_pos(const Point2i &p_mouse, int &r_row, int &r_col) const {
 	float rows = p_mouse.y;
-	rows -= cache.style_normal->get_margin(MARGIN_TOP);
+	rows -= cache.style_normal->get_margin(SIDE_TOP);
 	rows /= get_row_height();
 	rows += get_v_scroll_offset();
 	int first_vis_line = get_first_visible_line();
@@ -2061,7 +2061,7 @@ void TextEdit::_get_mouse_pos(const Point2i &p_mouse, int &r_row, int &r_col) co
 		row = text.size() - 1;
 		col = text[row].size();
 	} else {
-		int colx = p_mouse.x - (cache.style_normal->get_margin(MARGIN_LEFT) + gutters_width + gutter_padding);
+		int colx = p_mouse.x - (cache.style_normal->get_margin(SIDE_LEFT) + gutters_width + gutter_padding);
 		colx += cursor.x_ofs;
 
 		RID text_rid = text.get_line_data(row)->get_line_rid(wrap_index);
@@ -2089,7 +2089,7 @@ Vector2i TextEdit::_get_cursor_pixel_pos(bool p_adjust_viewport) {
 
 	// Calculate final pixel position
 	int y = (row - get_v_scroll_offset()) * get_row_height();
-	int x = cache.style_normal->get_margin(MARGIN_LEFT) + gutters_width + gutter_padding - cursor.x_ofs;
+	int x = cache.style_normal->get_margin(SIDE_LEFT) + gutters_width + gutter_padding - cursor.x_ofs;
 
 	Rect2 l_caret, t_caret;
 	TextServer::Direction l_dir, t_dir;
@@ -2106,7 +2106,7 @@ Vector2i TextEdit::_get_cursor_pixel_pos(bool p_adjust_viewport) {
 
 void TextEdit::_get_minimap_mouse_row(const Point2i &p_mouse, int &r_row) const {
 	float rows = p_mouse.y;
-	rows -= cache.style_normal->get_margin(MARGIN_TOP);
+	rows -= cache.style_normal->get_margin(SIDE_TOP);
 	rows /= (minimap_char_size.y + minimap_line_spacing);
 	rows += get_v_scroll_offset();
 
@@ -2234,7 +2234,7 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
 				int row, col;
 				_get_mouse_pos(Point2i(mpos.x, mpos.y), row, col);
 
-				int left_margin = cache.style_normal->get_margin(MARGIN_LEFT);
+				int left_margin = cache.style_normal->get_margin(SIDE_LEFT);
 				for (int i = 0; i < gutters.size(); i++) {
 					if (!gutters[i].draw || gutters[i].width <= 0) {
 						continue;
@@ -4575,7 +4575,7 @@ Control::CursorShape TextEdit::get_cursor_shape(const Point2 &p_pos) const {
 	int row, col;
 	_get_mouse_pos(p_pos, row, col);
 
-	int left_margin = cache.style_normal->get_margin(MARGIN_LEFT);
+	int left_margin = cache.style_normal->get_margin(SIDE_LEFT);
 	int gutter = left_margin + gutters_width;
 	if (p_pos.x < gutter) {
 		for (int i = 0; i < gutters.size(); i++) {
@@ -4593,7 +4593,7 @@ Control::CursorShape TextEdit::get_cursor_shape(const Point2 &p_pos) const {
 		return CURSOR_ARROW;
 	}
 
-	int xmargin_end = get_size().width - cache.style_normal->get_margin(MARGIN_RIGHT);
+	int xmargin_end = get_size().width - cache.style_normal->get_margin(SIDE_RIGHT);
 	if (draw_minimap && p_pos.x > xmargin_end - minimap_width && p_pos.x <= xmargin_end) {
 		return CURSOR_ARROW;
 	}
diff --git a/scene/gui/texture_progress_bar.cpp b/scene/gui/texture_progress_bar.cpp
index b5115690ac..8278bd3689 100644
--- a/scene/gui/texture_progress_bar.cpp
+++ b/scene/gui/texture_progress_bar.cpp
@@ -54,16 +54,16 @@ Ref<Texture2D> TextureProgressBar::get_over_texture() const {
 	return over;
 }
 
-void TextureProgressBar::set_stretch_margin(Margin p_margin, int p_size) {
-	ERR_FAIL_INDEX((int)p_margin, 4);
-	stretch_margin[p_margin] = p_size;
+void TextureProgressBar::set_stretch_margin(Side p_side, int p_size) {
+	ERR_FAIL_INDEX((int)p_side, 4);
+	stretch_margin[p_side] = p_size;
 	update();
 	minimum_size_changed();
 }
 
-int TextureProgressBar::get_stretch_margin(Margin p_margin) const {
-	ERR_FAIL_INDEX_V((int)p_margin, 4, 0);
-	return stretch_margin[p_margin];
+int TextureProgressBar::get_stretch_margin(Side p_side) const {
+	ERR_FAIL_INDEX_V((int)p_side, 4, 0);
+	return stretch_margin[p_side];
 }
 
 void TextureProgressBar::set_nine_patch_stretch(bool p_stretch) {
@@ -78,7 +78,7 @@ bool TextureProgressBar::get_nine_patch_stretch() const {
 
 Size2 TextureProgressBar::get_minimum_size() const {
 	if (nine_patch_stretch) {
-		return Size2(stretch_margin[MARGIN_LEFT] + stretch_margin[MARGIN_RIGHT], stretch_margin[MARGIN_TOP] + stretch_margin[MARGIN_BOTTOM]);
+		return Size2(stretch_margin[SIDE_LEFT] + stretch_margin[SIDE_RIGHT], stretch_margin[SIDE_TOP] + stretch_margin[SIDE_BOTTOM]);
 	} else if (under.is_valid()) {
 		return under->get_size();
 	} else if (over.is_valid()) {
@@ -206,8 +206,8 @@ Point2 TextureProgressBar::get_relative_center() {
 
 void TextureProgressBar::draw_nine_patch_stretched(const Ref<Texture2D> &p_texture, FillMode p_mode, double p_ratio, const Color &p_modulate) {
 	Vector2 texture_size = p_texture->get_size();
-	Vector2 topleft = Vector2(stretch_margin[MARGIN_LEFT], stretch_margin[MARGIN_TOP]);
-	Vector2 bottomright = Vector2(stretch_margin[MARGIN_RIGHT], stretch_margin[MARGIN_BOTTOM]);
+	Vector2 topleft = Vector2(stretch_margin[SIDE_LEFT], stretch_margin[SIDE_TOP]);
+	Vector2 bottomright = Vector2(stretch_margin[SIDE_RIGHT], stretch_margin[SIDE_BOTTOM]);
 
 	Rect2 src_rect = Rect2(Point2(), texture_size);
 	Rect2 dst_rect = Rect2(Point2(), get_size());
@@ -523,10 +523,10 @@ void TextureProgressBar::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "radial_center_offset"), "set_radial_center_offset", "get_radial_center_offset");
 	ADD_GROUP("Stretch", "stretch_");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "nine_patch_stretch"), "set_nine_patch_stretch", "get_nine_patch_stretch");
-	ADD_PROPERTYI(PropertyInfo(Variant::INT, "stretch_margin_left", PROPERTY_HINT_RANGE, "0,16384,1"), "set_stretch_margin", "get_stretch_margin", MARGIN_LEFT);
-	ADD_PROPERTYI(PropertyInfo(Variant::INT, "stretch_margin_top", PROPERTY_HINT_RANGE, "0,16384,1"), "set_stretch_margin", "get_stretch_margin", MARGIN_TOP);
-	ADD_PROPERTYI(PropertyInfo(Variant::INT, "stretch_margin_right", PROPERTY_HINT_RANGE, "0,16384,1"), "set_stretch_margin", "get_stretch_margin", MARGIN_RIGHT);
-	ADD_PROPERTYI(PropertyInfo(Variant::INT, "stretch_margin_bottom", PROPERTY_HINT_RANGE, "0,16384,1"), "set_stretch_margin", "get_stretch_margin", MARGIN_BOTTOM);
+	ADD_PROPERTYI(PropertyInfo(Variant::INT, "stretch_margin_left", PROPERTY_HINT_RANGE, "0,16384,1"), "set_stretch_margin", "get_stretch_margin", SIDE_LEFT);
+	ADD_PROPERTYI(PropertyInfo(Variant::INT, "stretch_margin_top", PROPERTY_HINT_RANGE, "0,16384,1"), "set_stretch_margin", "get_stretch_margin", SIDE_TOP);
+	ADD_PROPERTYI(PropertyInfo(Variant::INT, "stretch_margin_right", PROPERTY_HINT_RANGE, "0,16384,1"), "set_stretch_margin", "get_stretch_margin", SIDE_RIGHT);
+	ADD_PROPERTYI(PropertyInfo(Variant::INT, "stretch_margin_bottom", PROPERTY_HINT_RANGE, "0,16384,1"), "set_stretch_margin", "get_stretch_margin", SIDE_BOTTOM);
 
 	BIND_ENUM_CONSTANT(FILL_LEFT_TO_RIGHT);
 	BIND_ENUM_CONSTANT(FILL_RIGHT_TO_LEFT);
@@ -547,10 +547,10 @@ TextureProgressBar::TextureProgressBar() {
 	set_mouse_filter(MOUSE_FILTER_PASS);
 
 	nine_patch_stretch = false;
-	stretch_margin[MARGIN_LEFT] = 0;
-	stretch_margin[MARGIN_RIGHT] = 0;
-	stretch_margin[MARGIN_BOTTOM] = 0;
-	stretch_margin[MARGIN_TOP] = 0;
+	stretch_margin[SIDE_LEFT] = 0;
+	stretch_margin[SIDE_RIGHT] = 0;
+	stretch_margin[SIDE_BOTTOM] = 0;
+	stretch_margin[SIDE_TOP] = 0;
 
 	tint_under = tint_progress = tint_over = Color(1, 1, 1);
 }
diff --git a/scene/gui/texture_progress_bar.h b/scene/gui/texture_progress_bar.h
index 342e719a59..4fab8076fd 100644
--- a/scene/gui/texture_progress_bar.h
+++ b/scene/gui/texture_progress_bar.h
@@ -78,8 +78,8 @@ public:
 	void set_over_texture(const Ref<Texture2D> &p_texture);
 	Ref<Texture2D> get_over_texture() const;
 
-	void set_stretch_margin(Margin p_margin, int p_size);
-	int get_stretch_margin(Margin p_margin) const;
+	void set_stretch_margin(Side p_side, int p_size);
+	int get_stretch_margin(Side p_side) const;
 
 	void set_nine_patch_stretch(bool p_stretch);
 	bool get_nine_patch_stretch() const;
diff --git a/scene/gui/tree.cpp b/scene/gui/tree.cpp
index 063a5e7ac1..ad4545cf6c 100644
--- a/scene/gui/tree.cpp
+++ b/scene/gui/tree.cpp
@@ -1358,9 +1358,9 @@ int Tree::draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2
 
 			if (i == 0) {
 				if (p_item->cells[0].selected && select_mode == SELECT_ROW) {
-					Rect2i row_rect = Rect2i(Point2i(cache.bg->get_margin(MARGIN_LEFT), item_rect.position.y), Size2i(get_size().width - cache.bg->get_minimum_size().width, item_rect.size.y));
+					Rect2i row_rect = Rect2i(Point2i(cache.bg->get_margin(SIDE_LEFT), item_rect.position.y), Size2i(get_size().width - cache.bg->get_minimum_size().width, item_rect.size.y));
 					//Rect2 r = Rect2i(row_rect.pos,row_rect.size);
-					//r.grow(cache.selected->get_margin(MARGIN_LEFT));
+					//r.grow(cache.selected->get_margin(SIDE_LEFT));
 					if (rtl) {
 						row_rect.position.x = get_size().width - row_rect.position.x - row_rect.size.x;
 					}
@@ -1887,7 +1887,7 @@ int Tree::propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool
 			return -1;
 		} else if (col == 0) {
 			int margin = x_ofs + cache.item_margin; //-cache.hseparation;
-			//int lm = cache.bg->get_margin(MARGIN_LEFT);
+			//int lm = cache.bg->get_margin(SIDE_LEFT);
 			col_width -= margin;
 			col_ofs += margin;
 			x -= margin;
@@ -3005,8 +3005,8 @@ void Tree::update_scrollbars() {
 	Size2 hmin = h_scroll->get_combined_minimum_size();
 	Size2 vmin = v_scroll->get_combined_minimum_size();
 
-	v_scroll->set_begin(Point2(size.width - vmin.width, cache.bg->get_margin(MARGIN_TOP)));
-	v_scroll->set_end(Point2(size.width, size.height - cache.bg->get_margin(MARGIN_TOP) - cache.bg->get_margin(MARGIN_BOTTOM)));
+	v_scroll->set_begin(Point2(size.width - vmin.width, cache.bg->get_margin(SIDE_TOP)));
+	v_scroll->set_end(Point2(size.width, size.height - cache.bg->get_margin(SIDE_TOP) - cache.bg->get_margin(SIDE_BOTTOM)));
 
 	h_scroll->set_begin(Point2(0, size.height - hmin.height));
 	h_scroll->set_end(Point2(size.width - vmin.width, size.height));
@@ -3166,11 +3166,11 @@ void Tree::_notification(int p_what) {
 
 		if (show_column_titles) {
 			//title buttons
-			int ofs2 = cache.bg->get_margin(MARGIN_LEFT);
+			int ofs2 = cache.bg->get_margin(SIDE_LEFT);
 			for (int i = 0; i < columns.size(); i++) {
 				Ref<StyleBox> sb = (cache.click_type == Cache::CLICK_TITLE && cache.click_index == i) ? cache.title_button_pressed : ((cache.hover_type == Cache::CLICK_TITLE && cache.hover_index == i) ? cache.title_button_hover : cache.title_button);
 				Ref<Font> f = cache.tb_font;
-				Rect2 tbrect = Rect2(ofs2 - cache.offset.x, bg->get_margin(MARGIN_TOP), get_column_width(i), tbh);
+				Rect2 tbrect = Rect2(ofs2 - cache.offset.x, bg->get_margin(SIDE_TOP), get_column_width(i), tbh);
 				if (is_layout_rtl()) {
 					tbrect.position.x = get_size().width - tbrect.size.x - tbrect.position.x;
 				}
@@ -3470,7 +3470,7 @@ int Tree::get_column_width(int p_column) const {
 
 	Ref<StyleBox> bg = cache.bg;
 
-	int expand_area = get_size().width - (bg->get_margin(MARGIN_LEFT) + bg->get_margin(MARGIN_RIGHT));
+	int expand_area = get_size().width - (bg->get_margin(SIDE_LEFT) + bg->get_margin(SIDE_RIGHT));
 
 	if (v_scroll->is_visible_in_tree()) {
 		expand_area -= v_scroll->get_combined_minimum_size().width;
@@ -4249,7 +4249,7 @@ Tree::Tree() {
 	popup_editor_vb = memnew(VBoxContainer);
 	popup_editor->add_child(popup_editor_vb);
 	popup_editor_vb->add_theme_constant_override("separation", 0);
-	popup_editor_vb->set_anchors_and_margins_preset(PRESET_WIDE);
+	popup_editor_vb->set_anchors_and_offsets_preset(PRESET_WIDE);
 	text_editor = memnew(LineEdit);
 	popup_editor_vb->add_child(text_editor);
 	text_editor->set_v_size_flags(SIZE_EXPAND_FILL);