1 files changed, 154 insertions, 114 deletions

diff --git a/scene/gui/graph_node.cpp b/scene/gui/graph_node.cpp
index b07d401e6b..83c789f3d5 100644
--- a/scene/gui/graph_node.cpp
+++ b/scene/gui/graph_node.cpp
@@ -78,7 +78,7 @@ bool GraphNode::_set(const StringName &p_name, const Variant &p_value) {
 	}
 
 	set_slot(idx, si.enable_left, si.type_left, si.color_left, si.enable_right, si.type_right, si.color_right, si.custom_slot_left, si.custom_slot_right, si.draw_stylebox);
-	update();
+	queue_redraw();
 	return true;
 }
 
@@ -288,20 +288,20 @@ void GraphNode::_resort() {
 		idx++;
 	}
 
-	update();
+	queue_redraw();
 	connpos_dirty = true;
 }
 
 bool GraphNode::has_point(const Point2 &p_point) const {
 	if (comment) {
-		Ref<StyleBox> comment = get_theme_stylebox(SNAME("comment"));
+		Ref<StyleBox> comment_sb = get_theme_stylebox(SNAME("comment"));
 		Ref<Texture2D> resizer = get_theme_icon(SNAME("resizer"));
 
 		if (Rect2(get_size() - resizer->get_size(), resizer->get_size()).has_point(p_point)) {
 			return true;
 		}
 
-		if (Rect2(0, 0, get_size().width, comment->get_margin(SIDE_TOP)).has_point(p_point)) {
+		if (Rect2(0, 0, get_size().width, comment_sb->get_margin(SIDE_TOP)).has_point(p_point)) {
 			return true;
 		}
 
@@ -366,38 +366,46 @@ void GraphNode::_notification(int p_what) {
 				close_rect = Rect2();
 			}
 
-			for (const KeyValue<int, Slot> &E : slot_info) {
-				if (E.key < 0 || E.key >= cache_y.size()) {
-					continue;
-				}
-				if (!slot_info.has(E.key)) {
-					continue;
-				}
-				const Slot &s = slot_info[E.key];
-				// Left port.
-				if (s.enable_left) {
-					Ref<Texture2D> p = port;
-					if (s.custom_slot_left.is_valid()) {
-						p = s.custom_slot_left;
+			if (get_child_count() > 0) {
+				for (const KeyValue<int, Slot> &E : slot_info) {
+					if (E.key < 0 || E.key >= cache_y.size()) {
+						continue;
 					}
-					p->draw(get_canvas_item(), icofs + Point2(edgeofs, cache_y[E.key]), s.color_left);
-				}
-				// Right port.
-				if (s.enable_right) {
-					Ref<Texture2D> p = port;
-					if (s.custom_slot_right.is_valid()) {
-						p = s.custom_slot_right;
+					if (!slot_info.has(E.key)) {
+						continue;
+					}
+					const Slot &s = slot_info[E.key];
+					// Left port.
+					if (s.enable_left) {
+						Ref<Texture2D> p = port;
+						if (s.custom_slot_left.is_valid()) {
+							p = s.custom_slot_left;
+						}
+						p->draw(get_canvas_item(), icofs + Point2(edgeofs, cache_y[E.key]), s.color_left);
+					}
+					// Right port.
+					if (s.enable_right) {
+						Ref<Texture2D> p = port;
+						if (s.custom_slot_right.is_valid()) {
+							p = s.custom_slot_right;
+						}
+						p->draw(get_canvas_item(), icofs + Point2(get_size().x - edgeofs, cache_y[E.key]), s.color_right);
 					}
-					p->draw(get_canvas_item(), icofs + Point2(get_size().x - edgeofs, cache_y[E.key]), s.color_right);
-				}
 
-				// Draw slot stylebox.
-				if (s.draw_stylebox) {
-					Control *c = Object::cast_to<Control>(get_child(E.key));
-					Rect2 c_rect = c->get_rect();
-					c_rect.position.x = sb->get_margin(SIDE_LEFT);
-					c_rect.size.width = w;
-					draw_style_box(sb_slot, c_rect);
+					// Draw slot stylebox.
+					if (s.draw_stylebox) {
+						Control *c = Object::cast_to<Control>(get_child(E.key));
+						if (!c || !c->is_visible_in_tree()) {
+							continue;
+						}
+						if (c->is_set_as_top_level()) {
+							continue;
+						}
+						Rect2 c_rect = c->get_rect();
+						c_rect.position.x = sb->get_margin(SIDE_LEFT);
+						c_rect.size.width = w;
+						draw_style_box(sb_slot, c_rect);
+					}
 				}
 			}
 
@@ -416,7 +424,7 @@ void GraphNode::_notification(int p_what) {
 			_shape();
 
 			update_minimum_size();
-			update();
+			queue_redraw();
 		} break;
 	}
 }
@@ -475,7 +483,7 @@ void GraphNode::set_slot(int p_idx, bool p_enable_left, int p_type_left, const C
 	s.custom_slot_right = p_custom_right;
 	s.draw_stylebox = p_draw_stylebox;
 	slot_info[p_idx] = s;
-	update();
+	queue_redraw();
 	connpos_dirty = true;
 
 	emit_signal(SNAME("slot_updated"), p_idx);
@@ -483,13 +491,13 @@ void GraphNode::set_slot(int p_idx, bool p_enable_left, int p_type_left, const C
 
 void GraphNode::clear_slot(int p_idx) {
 	slot_info.erase(p_idx);
-	update();
+	queue_redraw();
 	connpos_dirty = true;
 }
 
 void GraphNode::clear_all_slots() {
 	slot_info.clear();
-	update();
+	queue_redraw();
 	connpos_dirty = true;
 }
 
@@ -508,7 +516,7 @@ void GraphNode::set_slot_enabled_left(int p_idx, bool p_enable_left) {
 	}
 
 	slot_info[p_idx].enable_left = p_enable_left;
-	update();
+	queue_redraw();
 	connpos_dirty = true;
 
 	emit_signal(SNAME("slot_updated"), p_idx);
@@ -522,7 +530,7 @@ void GraphNode::set_slot_type_left(int p_idx, int p_type_left) {
 	}
 
 	slot_info[p_idx].type_left = p_type_left;
-	update();
+	queue_redraw();
 	connpos_dirty = true;
 
 	emit_signal(SNAME("slot_updated"), p_idx);
@@ -543,7 +551,7 @@ void GraphNode::set_slot_color_left(int p_idx, const Color &p_color_left) {
 	}
 
 	slot_info[p_idx].color_left = p_color_left;
-	update();
+	queue_redraw();
 	connpos_dirty = true;
 
 	emit_signal(SNAME("slot_updated"), p_idx);
@@ -571,7 +579,7 @@ void GraphNode::set_slot_enabled_right(int p_idx, bool p_enable_right) {
 	}
 
 	slot_info[p_idx].enable_right = p_enable_right;
-	update();
+	queue_redraw();
 	connpos_dirty = true;
 
 	emit_signal(SNAME("slot_updated"), p_idx);
@@ -585,7 +593,7 @@ void GraphNode::set_slot_type_right(int p_idx, int p_type_right) {
 	}
 
 	slot_info[p_idx].type_right = p_type_right;
-	update();
+	queue_redraw();
 	connpos_dirty = true;
 
 	emit_signal(SNAME("slot_updated"), p_idx);
@@ -606,7 +614,7 @@ void GraphNode::set_slot_color_right(int p_idx, const Color &p_color_right) {
 	}
 
 	slot_info[p_idx].color_right = p_color_right;
-	update();
+	queue_redraw();
 	connpos_dirty = true;
 
 	emit_signal(SNAME("slot_updated"), p_idx);
@@ -630,7 +638,7 @@ void GraphNode::set_slot_draw_stylebox(int p_idx, bool p_enable) {
 	ERR_FAIL_COND_MSG(p_idx < 0, vformat("Cannot set draw_stylebox for the slot with p_idx (%d) lesser than zero.", p_idx));
 
 	slot_info[p_idx].draw_stylebox = p_enable;
-	update();
+	queue_redraw();
 	connpos_dirty = true;
 
 	emit_signal(SNAME("slot_updated"), p_idx);
@@ -688,7 +696,7 @@ void GraphNode::set_title(const String &p_title) {
 	title = p_title;
 	_shape();
 
-	update();
+	queue_redraw();
 	update_minimum_size();
 }
 
@@ -701,7 +709,7 @@ void GraphNode::set_text_direction(Control::TextDirection p_text_direction) {
 	if (text_direction != p_text_direction) {
 		text_direction = p_text_direction;
 		_shape();
-		update();
+		queue_redraw();
 	}
 }
 
@@ -713,7 +721,7 @@ void GraphNode::set_language(const String &p_language) {
 	if (language != p_language) {
 		language = p_language;
 		_shape();
-		update();
+		queue_redraw();
 	}
 }
 
@@ -728,7 +736,7 @@ void GraphNode::set_position_offset(const Vector2 &p_offset) {
 
 	position_offset = p_offset;
 	emit_signal(SNAME("position_offset_changed"));
-	update();
+	queue_redraw();
 }
 
 Vector2 GraphNode::get_position_offset() const {
@@ -736,12 +744,13 @@ Vector2 GraphNode::get_position_offset() const {
 }
 
 void GraphNode::set_selected(bool p_selected) {
-	if (selected == p_selected) {
+	if (!is_selectable() || selected == p_selected) {
 		return;
 	}
 
 	selected = p_selected;
-	update();
+	emit_signal(p_selected ? SNAME("selected") : SNAME("deselected"));
+	queue_redraw();
 }
 
 bool GraphNode::is_selected() {
@@ -766,7 +775,7 @@ void GraphNode::set_show_close_button(bool p_enable) {
 	}
 
 	show_close = p_enable;
-	update();
+	queue_redraw();
 }
 
 bool GraphNode::is_close_button_visible() const {
@@ -778,8 +787,8 @@ void GraphNode::_connpos_update() {
 	int sep = get_theme_constant(SNAME("separation"));
 
 	Ref<StyleBox> sb = get_theme_stylebox(SNAME("frame"));
-	conn_input_cache.clear();
-	conn_output_cache.clear();
+	left_port_cache.clear();
+	right_port_cache.clear();
 	int vofs = 0;
 
 	int idx = 0;
@@ -800,20 +809,26 @@ void GraphNode::_connpos_update() {
 
 		if (slot_info.has(idx)) {
 			if (slot_info[idx].enable_left) {
-				ConnCache cc;
-				cc.pos = Point2i(edgeofs, y + h / 2);
+				PortCache cc;
+				cc.position = Point2i(edgeofs, y + h / 2);
+				cc.height = size.height;
+
+				cc.slot_idx = idx;
 				cc.type = slot_info[idx].type_left;
 				cc.color = slot_info[idx].color_left;
-				cc.height = size.height;
-				conn_input_cache.push_back(cc);
+
+				left_port_cache.push_back(cc);
 			}
 			if (slot_info[idx].enable_right) {
-				ConnCache cc;
-				cc.pos = Point2i(get_size().width - edgeofs, y + h / 2);
+				PortCache cc;
+				cc.position = Point2i(get_size().width - edgeofs, y + h / 2);
+				cc.height = size.height;
+
+				cc.slot_idx = idx;
 				cc.type = slot_info[idx].type_right;
 				cc.color = slot_info[idx].color_right;
-				cc.height = size.height;
-				conn_output_cache.push_back(cc);
+
+				right_port_cache.push_back(cc);
 			}
 		}
 
@@ -830,46 +845,55 @@ int GraphNode::get_connection_input_count() {
 		_connpos_update();
 	}
 
-	return conn_input_cache.size();
+	return left_port_cache.size();
 }
 
-int GraphNode::get_connection_input_height(int p_idx) {
+int GraphNode::get_connection_input_height(int p_port) {
 	if (connpos_dirty) {
 		_connpos_update();
 	}
 
-	ERR_FAIL_INDEX_V(p_idx, conn_input_cache.size(), 0);
-	return conn_input_cache[p_idx].height;
+	ERR_FAIL_INDEX_V(p_port, left_port_cache.size(), 0);
+	return left_port_cache[p_port].height;
 }
 
-Vector2 GraphNode::get_connection_input_position(int p_idx) {
+Vector2 GraphNode::get_connection_input_position(int p_port) {
 	if (connpos_dirty) {
 		_connpos_update();
 	}
 
-	ERR_FAIL_INDEX_V(p_idx, conn_input_cache.size(), Vector2());
-	Vector2 pos = conn_input_cache[p_idx].pos;
+	ERR_FAIL_INDEX_V(p_port, left_port_cache.size(), Vector2());
+	Vector2 pos = left_port_cache[p_port].position;
 	pos.x *= get_scale().x;
 	pos.y *= get_scale().y;
 	return pos;
 }
 
-int GraphNode::get_connection_input_type(int p_idx) {
+int GraphNode::get_connection_input_type(int p_port) {
+	if (connpos_dirty) {
+		_connpos_update();
+	}
+
+	ERR_FAIL_INDEX_V(p_port, left_port_cache.size(), 0);
+	return left_port_cache[p_port].type;
+}
+
+Color GraphNode::get_connection_input_color(int p_port) {
 	if (connpos_dirty) {
 		_connpos_update();
 	}
 
-	ERR_FAIL_INDEX_V(p_idx, conn_input_cache.size(), 0);
-	return conn_input_cache[p_idx].type;
+	ERR_FAIL_INDEX_V(p_port, left_port_cache.size(), Color());
+	return left_port_cache[p_port].color;
 }
 
-Color GraphNode::get_connection_input_color(int p_idx) {
+int GraphNode::get_connection_input_slot(int p_port) {
 	if (connpos_dirty) {
 		_connpos_update();
 	}
 
-	ERR_FAIL_INDEX_V(p_idx, conn_input_cache.size(), Color());
-	return conn_input_cache[p_idx].color;
+	ERR_FAIL_INDEX_V(p_port, left_port_cache.size(), -1);
+	return left_port_cache[p_port].slot_idx;
 }
 
 int GraphNode::get_connection_output_count() {
@@ -877,46 +901,55 @@ int GraphNode::get_connection_output_count() {
 		_connpos_update();
 	}
 
-	return conn_output_cache.size();
+	return right_port_cache.size();
 }
 
-int GraphNode::get_connection_output_height(int p_idx) {
+int GraphNode::get_connection_output_height(int p_port) {
 	if (connpos_dirty) {
 		_connpos_update();
 	}
 
-	ERR_FAIL_INDEX_V(p_idx, conn_output_cache.size(), 0);
-	return conn_output_cache[p_idx].height;
+	ERR_FAIL_INDEX_V(p_port, right_port_cache.size(), 0);
+	return right_port_cache[p_port].height;
 }
 
-Vector2 GraphNode::get_connection_output_position(int p_idx) {
+Vector2 GraphNode::get_connection_output_position(int p_port) {
 	if (connpos_dirty) {
 		_connpos_update();
 	}
 
-	ERR_FAIL_INDEX_V(p_idx, conn_output_cache.size(), Vector2());
-	Vector2 pos = conn_output_cache[p_idx].pos;
+	ERR_FAIL_INDEX_V(p_port, right_port_cache.size(), Vector2());
+	Vector2 pos = right_port_cache[p_port].position;
 	pos.x *= get_scale().x;
 	pos.y *= get_scale().y;
 	return pos;
 }
 
-int GraphNode::get_connection_output_type(int p_idx) {
+int GraphNode::get_connection_output_type(int p_port) {
 	if (connpos_dirty) {
 		_connpos_update();
 	}
 
-	ERR_FAIL_INDEX_V(p_idx, conn_output_cache.size(), 0);
-	return conn_output_cache[p_idx].type;
+	ERR_FAIL_INDEX_V(p_port, right_port_cache.size(), 0);
+	return right_port_cache[p_port].type;
 }
 
-Color GraphNode::get_connection_output_color(int p_idx) {
+Color GraphNode::get_connection_output_color(int p_port) {
 	if (connpos_dirty) {
 		_connpos_update();
 	}
 
-	ERR_FAIL_INDEX_V(p_idx, conn_output_cache.size(), Color());
-	return conn_output_cache[p_idx].color;
+	ERR_FAIL_INDEX_V(p_port, right_port_cache.size(), Color());
+	return right_port_cache[p_port].color;
+}
+
+int GraphNode::get_connection_output_slot(int p_port) {
+	if (connpos_dirty) {
+		_connpos_update();
+	}
+
+	ERR_FAIL_INDEX_V(p_port, right_port_cache.size(), -1);
+	return right_port_cache[p_port].slot_idx;
 }
 
 void GraphNode::gui_input(const Ref<InputEvent> &p_ev) {
@@ -970,7 +1003,7 @@ void GraphNode::set_overlay(Overlay p_overlay) {
 	}
 
 	overlay = p_overlay;
-	update();
+	queue_redraw();
 }
 
 GraphNode::Overlay GraphNode::get_overlay() const {
@@ -983,7 +1016,7 @@ void GraphNode::set_comment(bool p_enable) {
 	}
 
 	comment = p_enable;
-	update();
+	queue_redraw();
 }
 
 bool GraphNode::is_comment() const {
@@ -996,7 +1029,7 @@ void GraphNode::set_resizable(bool p_enable) {
 	}
 
 	resizable = p_enable;
-	update();
+	queue_redraw();
 }
 
 bool GraphNode::is_resizable() const {
@@ -1012,6 +1045,9 @@ bool GraphNode::is_draggable() {
 }
 
 void GraphNode::set_selectable(bool p_selectable) {
+	if (!p_selectable) {
+		set_selected(false);
+	}
 	selectable = p_selectable;
 }
 
@@ -1046,30 +1082,30 @@ void GraphNode::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_language", "language"), &GraphNode::set_language);
 	ClassDB::bind_method(D_METHOD("get_language"), &GraphNode::get_language);
 
-	ClassDB::bind_method(D_METHOD("set_slot", "idx", "enable_left", "type_left", "color_left", "enable_right", "type_right", "color_right", "custom_left", "custom_right", "enable"), &GraphNode::set_slot, DEFVAL(Ref<Texture2D>()), DEFVAL(Ref<Texture2D>()), DEFVAL(true));
-	ClassDB::bind_method(D_METHOD("clear_slot", "idx"), &GraphNode::clear_slot);
+	ClassDB::bind_method(D_METHOD("set_slot", "slot_index", "enable_left_port", "type_left", "color_left", "enable_right_port", "type_right", "color_right", "custom_icon_left", "custom_icon_right", "draw_stylebox"), &GraphNode::set_slot, DEFVAL(Ref<Texture2D>()), DEFVAL(Ref<Texture2D>()), DEFVAL(true));
+	ClassDB::bind_method(D_METHOD("clear_slot", "slot_index"), &GraphNode::clear_slot);
 	ClassDB::bind_method(D_METHOD("clear_all_slots"), &GraphNode::clear_all_slots);
 
-	ClassDB::bind_method(D_METHOD("is_slot_enabled_left", "idx"), &GraphNode::is_slot_enabled_left);
-	ClassDB::bind_method(D_METHOD("set_slot_enabled_left", "idx", "enable_left"), &GraphNode::set_slot_enabled_left);
+	ClassDB::bind_method(D_METHOD("set_slot_enabled_left", "slot_index", "enable"), &GraphNode::set_slot_enabled_left);
+	ClassDB::bind_method(D_METHOD("is_slot_enabled_left", "slot_index"), &GraphNode::is_slot_enabled_left);
 
-	ClassDB::bind_method(D_METHOD("set_slot_type_left", "idx", "type_left"), &GraphNode::set_slot_type_left);
-	ClassDB::bind_method(D_METHOD("get_slot_type_left", "idx"), &GraphNode::get_slot_type_left);
+	ClassDB::bind_method(D_METHOD("set_slot_type_left", "slot_index", "type"), &GraphNode::set_slot_type_left);
+	ClassDB::bind_method(D_METHOD("get_slot_type_left", "slot_index"), &GraphNode::get_slot_type_left);
 
-	ClassDB::bind_method(D_METHOD("set_slot_color_left", "idx", "color_left"), &GraphNode::set_slot_color_left);
-	ClassDB::bind_method(D_METHOD("get_slot_color_left", "idx"), &GraphNode::get_slot_color_left);
+	ClassDB::bind_method(D_METHOD("set_slot_color_left", "slot_index", "color"), &GraphNode::set_slot_color_left);
+	ClassDB::bind_method(D_METHOD("get_slot_color_left", "slot_index"), &GraphNode::get_slot_color_left);
 
-	ClassDB::bind_method(D_METHOD("is_slot_enabled_right", "idx"), &GraphNode::is_slot_enabled_right);
-	ClassDB::bind_method(D_METHOD("set_slot_enabled_right", "idx", "enable_right"), &GraphNode::set_slot_enabled_right);
+	ClassDB::bind_method(D_METHOD("set_slot_enabled_right", "slot_index", "enable"), &GraphNode::set_slot_enabled_right);
+	ClassDB::bind_method(D_METHOD("is_slot_enabled_right", "slot_index"), &GraphNode::is_slot_enabled_right);
 
-	ClassDB::bind_method(D_METHOD("set_slot_type_right", "idx", "type_right"), &GraphNode::set_slot_type_right);
-	ClassDB::bind_method(D_METHOD("get_slot_type_right", "idx"), &GraphNode::get_slot_type_right);
+	ClassDB::bind_method(D_METHOD("set_slot_type_right", "slot_index", "type"), &GraphNode::set_slot_type_right);
+	ClassDB::bind_method(D_METHOD("get_slot_type_right", "slot_index"), &GraphNode::get_slot_type_right);
 
-	ClassDB::bind_method(D_METHOD("set_slot_color_right", "idx", "color_right"), &GraphNode::set_slot_color_right);
-	ClassDB::bind_method(D_METHOD("get_slot_color_right", "idx"), &GraphNode::get_slot_color_right);
+	ClassDB::bind_method(D_METHOD("set_slot_color_right", "slot_index", "color"), &GraphNode::set_slot_color_right);
+	ClassDB::bind_method(D_METHOD("get_slot_color_right", "slot_index"), &GraphNode::get_slot_color_right);
 
-	ClassDB::bind_method(D_METHOD("is_slot_draw_stylebox", "idx"), &GraphNode::is_slot_draw_stylebox);
-	ClassDB::bind_method(D_METHOD("set_slot_draw_stylebox", "idx", "draw_stylebox"), &GraphNode::set_slot_draw_stylebox);
+	ClassDB::bind_method(D_METHOD("is_slot_draw_stylebox", "slot_index"), &GraphNode::is_slot_draw_stylebox);
+	ClassDB::bind_method(D_METHOD("set_slot_draw_stylebox", "slot_index", "enable"), &GraphNode::set_slot_draw_stylebox);
 
 	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);
@@ -1090,16 +1126,18 @@ void GraphNode::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("is_selected"), &GraphNode::is_selected);
 
 	ClassDB::bind_method(D_METHOD("get_connection_input_count"), &GraphNode::get_connection_input_count);
-	ClassDB::bind_method(D_METHOD("get_connection_input_height", "idx"), &GraphNode::get_connection_input_height);
-	ClassDB::bind_method(D_METHOD("get_connection_input_position", "idx"), &GraphNode::get_connection_input_position);
-	ClassDB::bind_method(D_METHOD("get_connection_input_type", "idx"), &GraphNode::get_connection_input_type);
-	ClassDB::bind_method(D_METHOD("get_connection_input_color", "idx"), &GraphNode::get_connection_input_color);
+	ClassDB::bind_method(D_METHOD("get_connection_input_height", "port"), &GraphNode::get_connection_input_height);
+	ClassDB::bind_method(D_METHOD("get_connection_input_position", "port"), &GraphNode::get_connection_input_position);
+	ClassDB::bind_method(D_METHOD("get_connection_input_type", "port"), &GraphNode::get_connection_input_type);
+	ClassDB::bind_method(D_METHOD("get_connection_input_color", "port"), &GraphNode::get_connection_input_color);
+	ClassDB::bind_method(D_METHOD("get_connection_input_slot", "port"), &GraphNode::get_connection_input_slot);
 
 	ClassDB::bind_method(D_METHOD("get_connection_output_count"), &GraphNode::get_connection_output_count);
-	ClassDB::bind_method(D_METHOD("get_connection_output_height", "idx"), &GraphNode::get_connection_output_height);
-	ClassDB::bind_method(D_METHOD("get_connection_output_position", "idx"), &GraphNode::get_connection_output_position);
-	ClassDB::bind_method(D_METHOD("get_connection_output_type", "idx"), &GraphNode::get_connection_output_type);
-	ClassDB::bind_method(D_METHOD("get_connection_output_color", "idx"), &GraphNode::get_connection_output_color);
+	ClassDB::bind_method(D_METHOD("get_connection_output_height", "port"), &GraphNode::get_connection_output_height);
+	ClassDB::bind_method(D_METHOD("get_connection_output_position", "port"), &GraphNode::get_connection_output_position);
+	ClassDB::bind_method(D_METHOD("get_connection_output_type", "port"), &GraphNode::get_connection_output_type);
+	ClassDB::bind_method(D_METHOD("get_connection_output_color", "port"), &GraphNode::get_connection_output_color);
+	ClassDB::bind_method(D_METHOD("get_connection_output_slot", "port"), &GraphNode::get_connection_output_slot);
 
 	ClassDB::bind_method(D_METHOD("set_show_close_button", "show"), &GraphNode::set_show_close_button);
 	ClassDB::bind_method(D_METHOD("is_close_button_visible"), &GraphNode::is_close_button_visible);
@@ -1123,6 +1161,8 @@ void GraphNode::_bind_methods() {
 	ADD_GROUP("", "");
 
 	ADD_SIGNAL(MethodInfo("position_offset_changed"));
+	ADD_SIGNAL(MethodInfo("selected"));
+	ADD_SIGNAL(MethodInfo("deselected"));
 	ADD_SIGNAL(MethodInfo("slot_updated", PropertyInfo(Variant::INT, "idx")));
 	ADD_SIGNAL(MethodInfo("dragged", PropertyInfo(Variant::VECTOR2, "from"), PropertyInfo(Variant::VECTOR2, "to")));
 	ADD_SIGNAL(MethodInfo("raise_request"));