gdharness 1.1.21 → 1.1.22

package/build/godot/addons/gdharness_runtime/runtime_paths.gd

@@ -198,7 +198,7 @@ static func can_read(holder: Variant, named: String) -> bool:
 		var map: Dictionary = holder
 		if not method_of(named).is_empty():
 			return method_of(named) in MAP_CALLS
-		return map.has(named) or map.has(StringName(named))
+		return not _key_in(map, named).is_empty()
 	if holder is Object:
 		var object: Object = holder
 		var method: String = method_of(named)
@@ -208,6 +208,23 @@ static func can_read(holder: Variant, named: String) -> bool:
 	return false
 
 
+## The key of [param map] a step names, in a list of one, or an empty list when it names none.
+##
+## A step is text, and a map is keyed by whatever the game put in it: text, a StringName, or a
+## number, which a map of units by id is. Keyed by 3, "3" is not a key of it, measured on 4.7.2, so a
+## step that reads as a number is tried as one after the two spellings of text.
+static func _key_in(map: Dictionary, named: String) -> Array:
+	var spellings: Array = [named, StringName(named)]
+	if named.is_valid_int():
+		spellings.append(int(named))
+	if named.is_valid_float():
+		spellings.append(float(named))
+	for key: Variant in spellings:
+		if map.has(key):
+			return [key]
+	return []
+
+
 ## The method a step written as a call names, "get_viewport()" being get_viewport, or "" for a
 ## step that is a name.
 static func method_of(named: String) -> String:
@@ -243,10 +260,7 @@ static func write(holder: Variant, named: String, value: Variant) -> void:
 		var map: Dictionary = holder
 		# Written back under the key it was found under, since a map keyed by StringName and one
 		# keyed by String both read the same way and a write to the wrong one adds a second entry.
-		if map.has(named):
-			map[named] = value
-		else:
-			map[StringName(named)] = value
+		map[_key_in(map, named)[0]] = value
 		return
 	var object: Object = holder
 	object.set(named, value)
@@ -265,9 +279,7 @@ static func read_under(holder: Variant, named: String) -> Variant:
 		return list[_index_in(named, len(holder))]
 	if holder is Dictionary:
 		var map: Dictionary = holder
-		if map.has(named):
-			return map[named]
-		return map[StringName(named)]
+		return map[_key_in(map, named)[0]]
 	var object: Object = holder
 	var method: String = method_of(named)
 	if not method.is_empty():
@@ -311,6 +323,14 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 			return container_calls_refused(called_as, "a map", container_call)
 		var map: Dictionary = holder
 		var keys: Array = map.keys()
+		# A key reading as the step and still not reached is one of a type a step cannot spell, and
+		# saying the map has no key 3 while listing 3 among its keys contradicts itself.
+		for key: Variant in keys:
+			if str(key) == named:
+				return (
+					"%s has a key that reads %s, but it is %s, which a path step cannot name"
+					% [called_as, named, type_string(typeof(key))]
+				)
 		# Eight of them, because a map keyed by something unexpected is told by the first few and a
 		# map of two hundred would bury the sentence saying which key was missing.
 		var some: Array[String] = []

package/build/godot/addons/gdharness_runtime/runtime_queries.gd

@@ -1,7 +1,8 @@
 extends RefCounted
 
 ## What the server asks about the running tree: its shape, one node, the nodes matching a
-## question, where one is on screen, a property set, a method called, the metrics.
+## question, where one is on screen, a property's value, the metrics. What it changes, a property
+## written or a method called, is in runtime_changes.gd.
 
 const Paths = preload("runtime_paths.gd")
 const Read = preload("reading.gd")
@@ -360,6 +361,11 @@ static func _drawn(node: Node) -> bool:
 	var control: CanvasItem = node as CanvasItem
 	if control != null:
 		return control.visible
+	# A hidden layer hides everything drawn on it, a pause menu's for one, while each of those keeps
+	# its own visible flag, so read as shown it matched the words of a menu nobody could see.
+	var layer: CanvasLayer = node as CanvasLayer
+	if layer != null:
+		return layer.visible
 	var spatial: Node3D = node as Node3D
 	if spatial != null:
 		return spatial.visible
@@ -562,304 +568,6 @@ func get_property(params: Dictionary) -> Dictionary:
 	}
 
 
-func set_property(params: Dictionary) -> Dictionary:
-	var node_path: String = str(params.get("path", ""))
-	var property: String = str(params.get("property", ""))
-	var value: Variant = params.get("value")
-
-	if node_path.is_empty() or property.is_empty():
-		return {"type": "error", "message": "Node path and property required"}
-
-	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
-	if standing.has("message"):
-		return standing
-	var node: Node = standing["node"]
-
-	# Through a path as well, for the reason [method Paths.walk_to] gives, and read back off the same
-	# holder afterwards: a set that does not take says so by answering with the old value, which is
-	# how a typed container refusing a write is told from one accepting it.
-	var reached: Dictionary = Paths.walk_to(node, node_path, property)
-	if reached.has("message"):
-		return reached
-
-	var holder: Variant = reached["holder"]
-	var named: String = reached["name"]
-	# A call can be walked through and read, and is not a place: what it returns is the method's
-	# to hand out, and writing "into" it would set nothing the game keeps.
-	if not Paths.method_of(named).is_empty():
-		return {
-			"type": "error",
-			"message":
-			(
-				"%s:%s is a call, and a call is not a place to write: name a property"
-				% [reached["called"], named]
-			)
-		}
-	if not Paths.can_read(holder, named):
-		return {"type": "error", "message": Paths.nothing_there(holder, named, str(reached["called"]))}
-	var old_value: Variant = Paths.read_under(holder, named)
-	# The same rule the call path holds: a value that cannot become what the property holds is
-	# refused rather than written. Writing it means the engine picks something, and what it picks
-	# for a word where a number goes is zero, which the answer then reports as the new value.
-	var slot: Dictionary = Values.slot_declared(holder, named)
-	var wanted: int = slot["type"] if slot["type"] != TYPE_NIL else typeof(old_value)
-	var given: Variant
-	if wanted == TYPE_OBJECT and (value is String or value is Dictionary):
-		var named_object: Dictionary = _object_named(node, node_path, value, str(slot["class"]))
-		if named_object.has("message"):
-			return {
-				"type": "error",
-				"message": "%s.%s holds an object: %s" % [reached["called"], named, named_object["message"]]
-			}
-		given = named_object["object"]
-	else:
-		given = _values.fitted(value, wanted)
-		if not Values.acceptable(given, wanted):
-			return {
-				"type": "error",
-				"message":
-				(
-					"%s.%s holds %s and the value given is %s, which cannot become one."
-					% [reached["called"], named, type_string(wanted), type_string(typeof(given))]
-				)
-			}
-		var typed: Dictionary = _values.typed_like(given, old_value, _element_object.bind(node, node_path))
-		if typed.has("message"):
-			return {
-				"type": "error",
-				"message":
-				"%s.%s is a typed %s: %s." % [reached["called"], named, _sort_of(old_value), typed["message"]]
-			}
-		given = typed["value"]
-	# The write alone, setter included, which is where a property's cost is.
-	var began: int = Time.get_ticks_usec()
-	Paths.write(holder, named, given)
-	var elapsed: int = Time.get_ticks_usec() - began
-	var now: Variant = Paths.read_under(holder, named)
-	# Read back rather than trusted. The engine drops a write it will not take without a word, and
-	# the answer then showed the old value as the new one, shaped as a success: a typed container
-	# refusing a plain list did exactly that. A value the property changed on the way in, a setter
-	# clamping it, still changed it, so only a write that left the property as it was is refused.
-	# And only one that asked for a change: the value the property already held, written again, left
-	# it as it was because nothing was asked of it.
-	var already: bool = _held_already(given, old_value)
-	if (
-		Values.comparable(given, old_value)
-		and not already
-		and Values.comparable(now, old_value)
-		and now == old_value
-	):
-		return {
-			"type": "error",
-			"message":
-			(
-				(
-					"%s.%s was given %s and still holds %s: the engine kept what it had,"
-					+ " which a property it will not write does."
-				)
-				% [
-					reached["called"],
-					named,
-					JSON.stringify(_values.serialize(given)),
-					JSON.stringify(_values.serialize(now))
-				]
-			)
-		}
-
-	var answer: Dictionary = {
-		"type": "property_set",
-		"path": node_path,
-		"property": property,
-		"old_value": _values.serialize(old_value),
-		"new_value": _values.serialize(now),
-		"elapsed_usec": elapsed
-	}
-	if already and Values.comparable(now, old_value) and now == old_value:
-		answer["unchanged"] = true
-	return answer
-
-
-## Whether [param given] is the value [param held] already is, at the precision the property keeps.
-##
-## A float arrives as 64 bits and most engine properties keep 32: Camera3D.h_offset given -1.1
-## reads back as -1.10000002384186, so comparing the two exactly took a write of the value already
-## held for one the engine refused (#780). Rounding both to 32 bits is exact for a 32-bit property.
-## A 64-bit one can take a write this calls the same and read back changed, and the caller calls a
-## write unchanged only when it reads back as it was. What that cannot tell apart is a 64-bit
-## property whose setter ignored a value differing from the held one below 32 bits: it is answered
-## unchanged rather than refused. Vectors and colours hold 32-bit parts in the value itself, so they
-## already compare at the property's precision.
-static func _held_already(given: Variant, held: Variant) -> bool:
-	if not Values.comparable(given, held):
-		return false
-	if given == held:
-		return true
-	if typeof(given) != TYPE_FLOAT or typeof(held) != TYPE_FLOAT:
-		return false
-	return PackedFloat32Array([given])[0] == PackedFloat32Array([held])[0]
-
-
-func call_method(params: Dictionary) -> Dictionary:
-	var node_path: String = str(params.get("path", ""))
-	var method: String = str(params.get("method", ""))
-	var args: Array = params.get("args", [])
-
-	if node_path.is_empty() or method.is_empty():
-		return {"type": "error", "message": "Node path and method required"}
-
-	var standing: Dictionary = Values.node_at(_host.get_tree().root, node_path)
-	if standing.has("message"):
-		return standing
-	var node: Node = standing["node"]
-
-	# Through a path as well, for the reason [method Paths.walk_to] gives. What a game does hangs off its
-	# nodes as much as its state does, so reading `_game:run:day` while being unable to call
-	# `_game:run:advance` answers half of what a node holds and refuses the other half.
-	var reached: Dictionary = Paths.walk_to(node, node_path, method)
-	if reached.has("message"):
-		return reached
-
-	# A list or a map answers the calls a path makes on one, and nothing else: said in those terms
-	# rather than as "has no method", which reads as a misspelling of a method that was never going
-	# to be there, and with the element spelled out, since a method on what it holds is the usual aim.
-	if not reached["holder"] is Object:
-		var sort: String = "a list"
-		if reached["holder"] is Dictionary:
-			sort = "a map"
-		elif Paths.packed(reached["holder"]):
-			sort = "a packed list"
-		var spelled: String = str(reached["name"])
-		if Paths.method_of(spelled).is_empty():
-			spelled += "()"
-		if args.is_empty() and Paths.can_read(reached["holder"], spelled):
-			var read_from: int = Time.get_ticks_usec()
-			var answered: Variant = Paths.read_under(reached["holder"], spelled)
-			var read_for: int = Time.get_ticks_usec() - read_from
-			return {
-				"type": "method_result",
-				"path": node_path,
-				"method": method,
-				"result": _values.serialize(answered),
-				"elapsed_usec": read_for,
-			}
-		var why: String = (
-			"%s:%s takes no arguments" % [reached["called"], spelled]
-			if Paths.can_read(reached["holder"], spelled)
-			else Paths.nothing_there(reached["holder"], spelled, str(reached["called"]))
-		)
-		return {
-			"type": "error",
-			"message":
-			(
-				"%s. A method of what %s holds is called on the element, as in %s:0:%s"
-				% [why, sort, reached["called"], reached["name"]]
-			)
-		}
-	var holder: Object = reached["holder"]
-	var named: String = reached["name"]
-	# The method a call ends on is the one being called whether or not it carries the brackets a
-	# step along the way would: "get_viewport():gui_get_focus_owner()" is the same call as without
-	# the last pair.
-	if not Paths.method_of(named).is_empty():
-		named = Paths.method_of(named)
-	if not holder.has_method(named):
-		return {"type": "error", "message": "%s has no method %s" % [reached["called"], named]}
-
-	# Checked before the call rather than left to it. `callv` raises inside the game when an
-	# argument cannot be converted, and an error raised in a game somebody is playing holds it at a
-	# debugger break: every later call then reports a game that is not responding, which points
-	# nowhere near the argument. A wrong argument costs a refusal, never the session's game.
-	var deserialized_args: Array = []
-	for index: int in args.size():
-		var wants: int = _values.parameter_type(holder, named, index)
-		if wants == TYPE_OBJECT and (args[index] is String or args[index] is Dictionary):
-			var declared: String = _values.parameter_class(holder, named, index)
-			var named_object: Dictionary = _object_named(node, node_path, args[index], declared)
-			if named_object.has("message"):
-				return {
-					"type": "error",
-					"message":
-					"%s.%s argument %d: %s" % [reached["called"], named, index + 1, named_object["message"]]
-				}
-			deserialized_args.append(named_object["object"])
-			continue
-		var given: Variant = _values.fitted(args[index], wants)
-		if not Values.acceptable(given, wants):
-			return {
-				"type": "error",
-				"message":
-				(
-					"%s.%s takes %s as argument %d and was given %s, which cannot be converted."
-					% [reached["called"], named, type_string(wants), index + 1, type_string(typeof(given))]
-				)
-			}
-		# A typed list or map is built as one, since a plain one handed to such a parameter raises
-		# inside the game, which is what every check here exists to stop.
-		var container: Variant = _values.parameter_container(holder, named, index)
-		if container != null:
-			var typed: Dictionary = _values.typed_like(
-				given, container, _element_object.bind(node, node_path)
-			)
-			if typed.has("message"):
-				return {
-					"type": "error",
-					"message":
-					(
-						"%s.%s takes a typed %s as argument %d: %s."
-						% [reached["called"], named, _sort_of(container), index + 1, typed["message"]]
-					)
-				}
-			given = typed["value"]
-		deserialized_args.append(given)
-
-	# Timed around the call alone, since the bridge's round trip is a second or more and swamps what
-	# one click's work costs; the frame metrics read whichever frame is last, which is not this one.
-	var began: int = Time.get_ticks_usec()
-	var result: Variant = holder.callv(named, deserialized_args)
-	var elapsed: int = Time.get_ticks_usec() - began
-
-	return {
-		"type": "method_result",
-		"path": node_path,
-		"method": method,
-		"result": _values.serialize(result),
-		"elapsed_usec": elapsed
-	}
-
-
-## [method _object_named] with the path first, which is the order [method Values.typed_like] calls
-## an element resolver in.
-func _element_object(given: Variant, declared: String, node: Node, node_path: String) -> Dictionary:
-	return _object_named(node, node_path, given, declared)
-
-
-## "list" or "map", for a refusal about a typed container.
-static func _sort_of(container: Variant) -> String:
-	return "list" if container is Array else "map"
-
-
-## The object [param given] names for a slot or a parameter declared as [param declared], as
-## `{"object": ...}`, or `{"message": ...}` saying why it names none that fits.
-##
-## JSON cannot carry an object, so one the game holds is named by its path, read from the node the
-## call or the write was made on, and handed over as that instance rather than a copy: a method
-## given a piece of the game's state acts on the piece the game keeps, and a slot written with one
-## holds the game's own.
-##
-## The text null names no object, which is what an object slot or parameter takes to be emptied. A
-## caller's null arrived as that text in #772 and #783, and was looked up as a node called "null".
-func _object_named(node: Node, node_path: String, given: Variant, declared: String) -> Dictionary:
-	if given is String and str(given).strip_edges() == "null":
-		return {"object": null}
-	var found: Dictionary = Paths.object_at(_host.get_tree().root, node, node_path, given)
-	if found.has("message"):
-		return found
-	var instance: Object = found["object"]
-	if not declared.is_empty() and not Values.is_a(instance, declared):
-		return {"message": "%s is %s, not a %s" % [str(given), Values.class_of(instance), declared]}
-	return found
-
-
 func get_metrics(params: Dictionary) -> Dictionary:
 	var metrics: Array = params.get("metrics", [])
 	var all: Dictionary = {

package/build/godot/addons/gdharness_runtime/runtime_screen.gd

@@ -17,20 +17,32 @@ extends RefCounted
 ## sit inside another viewport. A SubViewport drawn some other way, onto a mesh for one, has no
 ## place on the screen to carry the point to, and the point stays in it.
 static func reach(viewport: Viewport, point: Vector2) -> Dictionary:
+	var out: Array[Dictionary] = steps_out(viewport, point)
+	return out.back()
+
+
+## Every viewport a pointer at [param point] in [param viewport] passes through on the way out to
+## the one it arrives at, innermost first, as {"viewport", "point", "through"}: the point in that
+## viewport's space, and the embedded [Window] or the [SubViewportContainer] in it that shows the
+## step before, null for the first. What [method reach] answers is the last of them.
+static func steps_out(viewport: Viewport, point: Vector2) -> Array[Dictionary]:
+	var out: Array[Dictionary] = [{"viewport": viewport, "point": point, "through": null}]
 	while true:
 		var window: Window = viewport as Window
 		if window != null and window.is_embedded() and window.get_parent() != null:
 			point += Vector2(window.position)
 			viewport = window.get_parent().get_viewport()
+			out.append({"viewport": viewport, "point": point, "through": window})
 			continue
 		var shown_by: SubViewportContainer = viewport.get_parent() as SubViewportContainer
 		if viewport is SubViewport and shown_by != null:
 			var scaled: Vector2 = point * float(shown_by.stretch_shrink) if shown_by.stretch else point
 			point = shown_by.get_global_transform_with_canvas() * scaled
 			viewport = shown_by.get_viewport()
+			out.append({"viewport": viewport, "point": point, "through": shown_by})
 			continue
 		break
-	return {"viewport": viewport, "point": point}
+	return out
 
 
 ## Where [param point], in [param viewport]'s own coordinates, is in the pixels of the window the

package/build/godot/addons/gdharness_runtime/runtime_targets.gd

@@ -5,6 +5,7 @@ extends RefCounted
 const Queries = preload("runtime_queries.gd")
 const Read = preload("reading.gd")
 const Says = preload("runtime_says.gd")
+const Screen = preload("runtime_screen.gd")
 const Values = preload("runtime_values.gd")
 const Words = preload("runtime_words.gd")
 
@@ -68,8 +69,12 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 	var areas: Array[Rect2] = _areas_of(drawn)
 	var covered: int = 0
 	var cover: Node = null
+	var outside: int = 0
 	var open: Array[int] = []
 	for index: int in matched.size():
+		if _off_screen(matched[index]):
+			outside += 1
+			continue
 		var over: Node = _cover_of(matched[index], drawn, areas)
 		if over == null:
 			open.append(index)
@@ -98,8 +103,8 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 			"type": "error",
 			"message":
 			(
-				'no control on screen%s says "%s", so nothing was clicked%s%s'
-				% [under, wanted, _hidden_note(hidden), _covered_note(covered, cover)]
+				'no control on screen%s says "%s", so nothing was clicked%s%s%s'
+				% [under, wanted, _hidden_note(hidden), _outside_note(outside), _covered_note(covered, cover)]
 			)
 		}
 	var best: int = ranks.count(ranks[0])
@@ -137,10 +142,13 @@ static func control_saying(root: Node, root_path: String, wanted: String, which:
 	return {"path": str(targets[index].get_path()), "found": found}
 
 
-## How good a match [param target] is for a click: a button over what cannot be pressed, and then
-## the whole of its words over a part of them.
+## How good a match [param target] is for a click: an enabled button over anything else, and then
+## the whole of its words over a part of them. A disabled button ranks with what is not a button,
+## since a click on it presses nothing: counted as a button, one tied with an enabled button saying
+## the same words and the click was refused as not clear.
 static func _rank(target: Control, whole: bool) -> int:
-	return (2 if target is BaseButton else 0) + (1 if whole else 0)
+	var button: BaseButton = target as BaseButton
+	return (2 if button != null and not button.disabled else 0) + (1 if whole else 0)
 
 
 ## Whether one of [param wanted]'s alternatives is the whole of [param said], or the whole of one of
@@ -178,14 +186,17 @@ static func _described(count: int, rank: int, wanted: String, under: String) ->
 	return "%d %ss on screen%s say %s" % [count, what, under, how]
 
 
-## Why the matches below [param rank] were passed over, said of one of them when [param one].
+## Why the matches below [param rank] were passed over, said of one of them when [param one]. As
+## what the code knows, which is whether a control is an enabled button: a card taking clicks in its
+## own `gui_input` is not one, and calling it something that cannot be pressed was a guess.
 static func _passed_over(rank: int, one: bool) -> String:
 	var says: String = "says" if one else "say"
+	var is_not: String = "is not an enabled button" if one else "are not enabled buttons"
 	match rank:
 		3:
-			return "cannot be pressed or %s it as part of more" % says
+			return "%s or %s it as part of more" % [is_not, says]
 		2:
-			return "cannot be pressed"
+			return is_not
 		_:
 			return "%s it as part of more" % says
 
@@ -197,6 +208,14 @@ static func _hidden_note(hidden: int) -> String:
 	return "; %d hidden control%s" % [hidden, " says it" if hidden == 1 else "s say it"]
 
 
+## What to add to a refusal that found nothing on screen, when words matched controls a click cannot
+## reach: off the viewport, or clipped away by a container it does not scroll.
+static func _outside_note(outside: int) -> String:
+	if outside == 0:
+		return ""
+	return "; %d control%s it outside what the screen shows" % [outside, " says" if outside == 1 else "s say"]
+
+
 ## What to add to a refusal that found nothing on screen, when the controls saying it are covered.
 static func _covered_note(covered: int, cover: Node) -> String:
 	if covered == 0:
@@ -271,26 +290,22 @@ static func _areas_of(drawn: Array[Node]) -> Array[Rect2]:
 ## page covered was picked over the ones in view, scrolled up under the page and pressed there.
 ##
 ## [param areas] holds the box around each of [param drawn], so everything whose box misses the
-## point is passed over before anything costlier is asked of it.
+## point is passed over before anything costlier is asked of it. A window's box is in the space of
+## the viewport it is embedded in, which is not the target's when the target is in another window,
+## so a window is judged by [method _window_over] instead.
 static func _cover_of(target: Control, drawn: Array[Node], areas: Array[Rect2]) -> Node:
 	var viewport: Viewport = target.get_viewport()
-	var point: Vector2 = target.get_global_transform_with_canvas() * (target.size * 0.5)
-	if _clipped_away(target, point):
-		point = _where_it_lands(target, point)
+	var point: Vector2 = _where_it_is_clicked(target)
 	var layer: int = _layer_of(target)
 	for at: int in drawn.size():
-		if not areas[at].has_point(point):
-			continue
 		var other: Node = drawn[at]
 		var window: Window = other as Window
 		if window != null:
-			if (
-				window.get_parent() != null
-				and window.get_parent().get_viewport() == viewport
-				and not window.is_ancestor_of(target)
-			):
+			if _window_over(target, point, window):
 				return window
 			continue
+		if not areas[at].has_point(point):
+			continue
 		var control: Control = other
 		if control == target or control.is_ancestor_of(target) or target.is_ancestor_of(control):
 			continue
@@ -304,6 +319,42 @@ static func _cover_of(target: Control, drawn: Array[Node], areas: Array[Rect2])
 	return null
 
 
+## Where a click at [param target] lands in its viewport: its centre, or where scrolling will bring
+## the centre when a ScrollContainer holding it clips it away, as the click scrolls it first.
+static func _where_it_is_clicked(target: Control) -> Vector2:
+	var point: Vector2 = target.get_global_transform_with_canvas() * (target.size * 0.5)
+	if _clipped_away(target, point):
+		point = _where_it_lands(target, point)
+	return point
+
+
+## Whether the embedded [param window] is drawn over [param point], [param target]'s centre in its
+## own viewport, with that point carried out to the viewport the window is embedded in.
+##
+## Over it when the window holds the point there and is not the window the target is in, and, when
+## the target is in another window embedded in the same place, when it is stacked above that one:
+## the embedder's list of windows runs from the bottom up, measured on 4.7.2. Judged only in the
+## target's own viewport, a confirmation over a settings dialog did not cover the dialog's OK, and
+## a click by words tied it with the confirmation's own.
+static func _window_over(target: Control, point: Vector2, window: Window) -> bool:
+	if window.get_parent() == null or window.is_ancestor_of(target):
+		return false
+	var host: Viewport = window.get_parent().get_viewport()
+	for step: Dictionary in Screen.steps_out(target.get_viewport(), point):
+		if step["viewport"] != host:
+			continue
+		var there: Vector2 = step["point"]
+		if not Rect2(window.position, window.size).has_point(there):
+			return false
+		var through: Variant = step["through"]
+		if not through is Window:
+			return true
+		var own: Window = through
+		var stacked: Array[Window] = host.get_embedded_subwindows()
+		return stacked.find(window) > stacked.find(own)
+	return false
+
+
 ## Whether [param control] holds [param point], given in its viewport's coordinates.
 static func _holds(control: Control, point: Vector2) -> bool:
 	var placed: Transform2D = control.get_global_transform_with_canvas()
@@ -316,17 +367,18 @@ static func _holds(control: Control, point: Vector2) -> bool:
 
 
 ## Where [param target]'s centre, now at [param point], will be once the click has scrolled it into
-## view: moved as little as puts the whole of it inside each container clipping it, innermost first,
-## which is how a scroll container brings a control into view. A target larger than a container is
-## centred in it.
+## view: moved as little as puts the whole of it inside each ScrollContainer holding it, innermost
+## first, which is how one brings a control into view. A target larger than a container is centred
+## in it. Only a ScrollContainer, because that is all a click scrolls: another container clipping
+## what it holds, a collapsed section for one, leaves the target where it is.
 static func _where_it_lands(target: Control, point: Vector2) -> Vector2:
 	var drawn: Transform2D = target.get_global_transform_with_canvas()
 	var half: Vector2 = (drawn * Rect2(Vector2.ZERO, target.size)).size * 0.5
 	var landed: Vector2 = point
 	var walk: Node = target.get_parent()
 	while walk != null:
-		var holder: Control = walk as Control
-		if holder != null and holder.clip_contents:
+		var holder: ScrollContainer = walk as ScrollContainer
+		if holder != null:
 			var shown: Rect2 = holder.get_global_transform_with_canvas() * Rect2(Vector2.ZERO, holder.size)
 			var low: Vector2 = shown.position + half
 			var high: Vector2 = shown.end - half
@@ -338,6 +390,20 @@ static func _where_it_lands(target: Control, point: Vector2) -> Vector2:
 	return landed
 
 
+## Whether a click could not reach [param target] however it scrolled: its centre, where the click
+## would bring it, outside its viewport or the one showing that on the screen, or clipped away by a
+## container the click does not scroll. A drawer parked off the side of the screen, or anything
+## outside the 64 by 64 viewport of a game with no window, was listed among the controls on screen.
+static func _off_screen(target: Control) -> bool:
+	var point: Vector2 = _where_it_is_clicked(target)
+	if _clipped_away(target, point) or not target.get_viewport().get_visible_rect().has_point(point):
+		return true
+	var reached: Dictionary = Screen.reach(target.get_viewport(), point)
+	var viewport: Viewport = reached["viewport"]
+	var there: Vector2 = reached["point"]
+	return not viewport.get_visible_rect().has_point(there)
+
+
 ## Whether a container clipping what it holds cuts [param point] off from [param control].
 static func _clipped_away(control: Control, point: Vector2) -> bool:
 	var walk: Node = control.get_parent()