gdharness 1.3.34 → 1.3.36

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

@@ -27,6 +27,11 @@ var _supplied: Dictionary[int, Array] = {}
 var _listened: Dictionary[int, bool] = {}
 var _inside: Dictionary[int, bool] = {}
 
+## The windows told here that the pointer is in them, and whether the telling is under way, since the
+## window answers it with the same mouse_entered the platform's enter sends.
+var _told: Dictionary[int, bool] = {}
+var _telling: bool = false
+
 ## Whether a script on a control declares `_has_point`, per script, since the search asks it of
 ## every control it passes.
 var _shapes: Dictionary[Script, bool] = {}
@@ -51,10 +56,26 @@ func follow(viewport: Viewport, point: Vector2) -> bool:
 	if not cannot_hover(window) or window.gui_get_hovered_control() != null:
 		_drop(window, 0)
 		return false
+	_tell_entered(window)
 	_hover(window, point)
 	return _supplied.has(window.get_instance_id())
 
 
+## Tells [param window] the pointer is in it, as Viewport.notify_mouse_entered is documented for
+## input pushed into a viewport. A native window hands a motion to the control under it only once
+## told, and only the platform's enter tells it: a motion pushed there reached no control's
+## _gui_input, so a control that draws its parts could be pressed and never hovered. Once a window,
+## until the platform says the pointer left it, since telling it twice is a warning.
+func _tell_entered(window: Window) -> void:
+	var id: int = window.get_instance_id()
+	if _told.get(id, false):
+		return
+	_told[id] = true
+	_telling = true
+	window.notify_mouse_entered()
+	_telling = false
+
+
 ## The control hovered in [param viewport], by the engine or by this.
 func hovered_in(viewport: Viewport) -> Control:
 	var own: Control = viewport.gui_get_hovered_control()
@@ -82,12 +103,15 @@ func _listen(window: Window) -> void:
 
 
 func _entered(window: Window) -> void:
+	if _telling:
+		return
 	_inside[window.get_instance_id()] = true
 	_drop(window, 0)
 
 
 func _left(window: Window) -> void:
 	_inside[window.get_instance_id()] = false
+	_told[window.get_instance_id()] = false
 
 
 ## Viewport::_update_mouse_over for [param point]: the control under it entered, from the outermost
@@ -201,6 +225,52 @@ func control_at(viewport: Viewport, point: Vector2) -> Control:
 	return null
 
 
+## What a pointer answer says of a press at [param position], in [param viewport]'s window pixels:
+## press_went_to, the path of what the GUI hands it to or null, and for a press aimed at a control,
+## landed, whether that is the control or inside it. Read before the press, which can free both. A
+## press aimed at a slider that went to a button drawn over it answered the slider's path alone,
+## and the caller read that as the slider having been pressed.
+func press_of(aim: Dictionary, viewport: Viewport, position: Vector2) -> Dictionary:
+	var took: Node = _pressed_at(viewport, viewport.get_final_transform().affine_inverse() * position)
+	var said: Dictionary = {"press_went_to": null}
+	if took != null:
+		said["press_went_to"] = str(took.get_path())
+	var named: Object = aim.get("node")
+	var aimed: Control = named as Control
+	if aimed != null:
+		said["landed"] = took != null and (took == aimed or aimed.is_ancestor_of(took))
+	return said
+
+
+## What a press at [param point], in [param viewport]'s own coordinates, goes to: the control the
+## GUI picks, carried into a window embedded over the point and into what a SubViewportContainer
+## shows, as the engine carries it; null when nothing there takes the pointer.
+func _pressed_at(viewport: Viewport, point: Vector2) -> Node:
+	var windows: Array[Window] = viewport.get_embedded_subwindows()
+	for index: int in range(windows.size() - 1, -1, -1):
+		var window: Window = windows[index]
+		if Rect2(window.position, window.size).has_point(point):
+			var inward: Transform2D = window.get_final_transform().affine_inverse()
+			var within: Node = _pressed_at(window, inward * (point - Vector2(window.position)))
+			if within == null:
+				return window
+			return within
+	var over: Control = control_at(viewport, point)
+	var container: SubViewportContainer = over as SubViewportContainer
+	if container == null:
+		return over
+	var inside: Vector2 = container.get_global_transform_with_canvas().affine_inverse() * point
+	if container.stretch:
+		inside /= container.stretch_shrink
+	for child: Node in container.get_children():
+		var shown: SubViewport = child as SubViewport
+		if shown != null and not shown.gui_disable_input:
+			var within: Node = _pressed_at(shown, shown.get_final_transform().affine_inverse() * inside)
+			if within != null:
+				return within
+	return container
+
+
 ## The controls [param node] holds that the engine keeps as roots of [param node]'s viewport: drawn
 ## on their own, or with no control above them. Not into another viewport, a window or a
 ## SubViewport, whose controls are that one's.