How to make scene instances unable to overlap each other?

Godoten Could you add a container control that for example sits at the center of the screen per default and that automatically layouts your dialogs? Maybe arrange them next to each other in at most two columns and then if you add a third dialog it adds a new row and shows the new dialog below the other two.

Edit: Or maybe just a tab container. Add a tab for every new dialog. After all, do you really need to show more than one or two on the screen at once?

I'm vomiting ideas here:

• draw() signal fires everytime a control node is redrawn, for example, when appearing, moving or resizing.
• a rect's position should be located at its top left corner by default, so:
  anywhere between rect.position and rect.position + rect.size would be occupied by rect.

you could use that draw() signal with the vector2 math above to convince your control nodes to behave how I think you're wanting them to behave.
if you're clever.
i am a lot more familiar with gdscript than most of godot's builtin functions, so please someone speak up if what i'm suggesting is unnecessarily hacky.

Godoten True but it's a good opportunity to challenge myself

Well if you want to challenge yourself, then you should figure it out on your own. By asking "how to", you're challenging the people on the forum instead

This can be done in several ways. Start by precisely describing the behavior. Can you drag one or multiple boxes at a time? Should they rearrange as you drag or only when you drop? Should they be pushed in the direction of drag or only moved out of the way... etc.

Godoten A quick and dirty custom implementation of rectangular Separating Axis Theorem should do the trick. It's been a while since I implemented one of those, so challenge accepted

main.gd:

extends Node2D

func separate(window1, window2, bias = .5):
	var r1 = window1.get_rect()
	var r2 = window2.get_rect()

	var ri = r1.intersection(r2)	
	if not ri.has_area():
		return

	var displace = Vector2.ZERO
	var o1 = r1.end - r2.position
	var o2 = r2.end - r1.position

	if(ri.size.x < ri.size.y):
		if abs(o1.x) < abs(o2.x):
			displace.x += o1.x
		else:
			displace.x -= o2.x	
	else:
		if abs(o1.y) < abs(o2.y):
			displace.y += o1.y
		else:
			displace.y -= o2.y	
	
	window2.position += displace * bias
	window1.position -= displace * (1-bias)

func _process(delta):
	for w1 in get_children():
		for w2 in get_children():
			if w1 != w2:
				var bias = .5
				if w1.dragging: 
					bias = 1
				elif w2.dragging:
					bias = 0
				separate(w1, w2, bias)

window.gd:

extends ColorRect

var dragging = false

func _gui_input(event):
	if event is InputEventMouseButton:
		if event.is_pressed():
			dragging = true
			modulate = Color(1.0, 0.0, 0.0, 1.0)

	if event is InputEventMouseMotion and dragging:
		position += event.relative

func _input(event):
	if event is InputEventMouseButton and not event.is_pressed():
		dragging = false
		modulate = Color(1.0, 1.0, 1.0, 1.0)

Note that running it once cannot guarantee cascaded separation in very crowded situations. However we run it every frame and it eventually sorts itself out throughout several frames, which is mostly unnoticeable.

You homework is to adapt it for multiple dragging windows, and optimize for performance