gdharness 1.3.8 → 1.3.10

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

@@ -21,15 +21,6 @@ const GdhMouse = preload("runtime_mouse.gd")
 ## everything that process starts. Kept in step with `DESKTOP_VARIABLE` in src/desktop.ts.
 const DESKTOP_VARIABLE: String = "GDHARNESS_DESKTOP"
 
-## Node.ProcessMode as its names, for a refusal to say which one is in force.
-const PROCESS_MODES: Dictionary[int, String] = {
-	Node.PROCESS_MODE_INHERIT: "INHERIT",
-	Node.PROCESS_MODE_PAUSABLE: "PAUSABLE",
-	Node.PROCESS_MODE_WHEN_PAUSED: "WHEN_PAUSED",
-	Node.PROCESS_MODE_ALWAYS: "ALWAYS",
-	Node.PROCESS_MODE_DISABLED: "DISABLED",
-}
-
 ## Whether this run has had the pointer note in full; the game process is the run.
 static var _pointer_explained: bool = false
 
@@ -151,50 +142,38 @@ func inject_action(params: Dictionary) -> Dictionary:
 		return {"type": "error", "message": "Action name required"}
 
 	if not InputMap.has_action(action):
-		return {"type": "error", "message": "Action not found: " + action}
+		return {"type": "error", "message": GdhValues.no_action(action)}
 	var holding: Variant = GdhValues.held_for(params)
 	if holding is String:
 		return {"type": "error", "message": holding}
 	var frames: int = holding
 
-	var focused: String = _focus_owner()
+	var focused: String = GdhValues.focus_path(_host)
 	_say_action(action, whole or held, strength)
+	var shortcuts: Dictionary = {"shortcuts": [], "shortcut_pressed": null}
+	if whole or held:
+		shortcuts = await GdhValues.press_shortcuts(_host.get_tree().root, action)
 	var lasted: Variant = null
 	if whole:
 		# A frame between the halves at least, as a click has: a listener that acts on the press and
 		# a listener that acts on the release both get their own frame to do it in.
 		lasted = await GdhValues.hold(_host.get_tree(), frames)
 		_say_action(action, false, strength)
-		await _host.get_tree().process_frame
-
-	return _focus_noted(
-		{
-			"type": "input_injected",
-			"input_type": "action",
-			"action": action,
-			"pressed": held and not whole,
-			"whole": whole,
-			"held_frames": GdhValues.held_answer(whole, frames),
-			"held_for": lasted,
-		},
-		focused
-	)
-
-
-## The path of the Control holding the keyboard focus, or "" when none does. Read before a key or an
-## action goes in, since pressing a focused button can move the focus.
-func _focus_owner() -> String:
-	var holding: Control = _host.get_viewport().gui_get_focus_owner()
-	return "" if holding == null else str(holding.get_path())
-
+	# The engine hands a parsed event on at the next frame, so the focus is read after one.
+	await _host.get_tree().process_frame
 
-## [param said] with [param focused], the Control that had the focus, under focused. A key or an action
-## reaches that Control before the game's _unhandled_input, so Space on a focused Button pressed it
-## and the game's own handler counted the key as well, with nothing in the answer saying why.
-static func _focus_noted(said: Dictionary, focused: String) -> Dictionary:
-	if not focused.is_empty():
-		said["focused"] = focused
-	return said
+	var answer: Dictionary = {
+		"type": "input_injected",
+		"input_type": "action",
+		"action": action,
+		"shortcuts": shortcuts["shortcuts"],
+		"shortcut_pressed": shortcuts["shortcut_pressed"],
+		"pressed": held and not whole,
+		"whole": whole,
+		"held_frames": GdhValues.held_answer(whole, frames),
+		"held_for": lasted,
+	}
+	return GdhValues.focus_noted(answer, focused, _host)
 
 
 func _say_action(action: String, down: bool, strength: float) -> void:
@@ -250,7 +229,7 @@ func inject_key(params: Dictionary) -> Dictionary:
 	# keys are the code points themselves, which is what makes this a mapping and not a table.
 	event.unicode = GdhValues.glyph_of(event.keycode, event.shift_pressed)
 
-	var focused: String = _focus_owner()
+	var focused: String = GdhValues.focus_path(_host)
 	Input.parse_input_event(event)
 	var lasted: Variant = null
 	if whole:
@@ -258,25 +237,24 @@ func inject_key(params: Dictionary) -> Dictionary:
 		var up: InputEventKey = event.duplicate()
 		up.pressed = false
 		Input.parse_input_event(up)
-		await _host.get_tree().process_frame
+	await _host.get_tree().process_frame
 
-	return _focus_noted(
-		{
-			"type": "input_injected",
-			"input_type": "key",
-			"held_frames": GdhValues.held_answer(whole, frames),
-			"held_for": lasted,
-			"keycode": event.keycode,
-			"physical_keycode": event.physical_keycode,
-			"shift": event.shift_pressed,
-			"ctrl": event.ctrl_pressed,
-			"alt": event.alt_pressed,
-			"unicode": event.unicode,
-			"pressed": held and not whole,
-			"whole": whole,
-		},
-		focused
-	)
+	var answer: Dictionary = {
+		"type": "input_injected",
+		"input_type": "key",
+		"held_frames": GdhValues.held_answer(whole, frames),
+		"held_for": lasted,
+		"keycode": event.keycode,
+		"physical_keycode": event.physical_keycode,
+		"shift": event.shift_pressed,
+		"ctrl": event.ctrl_pressed,
+		"alt": event.alt_pressed,
+		"unicode": event.unicode,
+		"actions": GdhValues.actions_of(event),
+		"pressed": held and not whole,
+		"whole": whole,
+	}
+	return GdhValues.focus_noted(answer, focused, _host)
 
 
 ## Clicks a mouse button at a position, and lets go of it again unless asked to hold it.
@@ -317,16 +295,28 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 	# its drag from the press, which is where a real pointer would be.
 	var _moved: Vector2 = _arrive(position)
 	var supplied: bool = _follow_in_the_window(position)
-	Input.parse_input_event(_button(position, button, whole or held, double))
+	# A double click's first click goes whole before it, as [method _click_button] sends one.
+	if double and held and not notch:
+		Input.parse_input_event(GdhMouse.button_event(position, button, true, false))
+		await _host.get_tree().process_frame
+		Input.parse_input_event(GdhMouse.button_event(position, button, false, false))
+		await _host.get_tree().process_frame
+	var press: InputEventMouseButton = GdhMouse.button_event(position, button, whole or held, double)
+	Input.parse_input_event(press)
 	var lasted: Variant = null
 	if notch:
-		Input.parse_input_event(_button(position, button, false, false))
+		Input.parse_input_event(GdhMouse.button_event(position, button, false, false))
 	elif whole:
 		# A frame between the halves at least, as inject_action has, so a control that acts on the
 		# press and one that acts on the release each get a frame to do it in.
 		lasted = await GdhValues.hold(_host.get_tree(), frames)
-		Input.parse_input_event(_button(position, button, false, false))
-		await _host.get_tree().process_frame
+		Input.parse_input_event(GdhMouse.button_event(position, button, false, false))
+	# Input hands the events on at the next frame, so the control under the pointer is read after it.
+	await _host.get_tree().process_frame
+	var hovered: Control = _hover.hovered_in(_host.get_viewport())
+	var hovered_path: Variant = null
+	if hovered != null:
+		hovered_path = str(hovered.get_path())
 
 	var at: Array[Vector2] = [position]
 	var said: Dictionary = _pointer_noted(
@@ -338,6 +328,8 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 				"held_for": lasted,
 				"position": [position.x, position.y],
 				"button": button,
+				"hovered": hovered_path,
+				"actions": GdhValues.actions_of(press),
 				"pressed": held and not whole,
 				"whole": whole,
 				"double": double
@@ -419,7 +411,7 @@ func inject_mouse_drag(params: Dictionary) -> Dictionary:
 	var end: Vector2 = points[points.size() - 1]
 	var _moved: Vector2 = _arrive(start)
 	var supplied: bool = _follow_in_the_window(start)
-	Input.parse_input_event(_button(start, button, true, false))
+	Input.parse_input_event(GdhMouse.button_event(start, button, true, false))
 	var travelled: Vector2 = Vector2.ZERO
 	for step: int in range(1, frames + 1):
 		await _host.get_tree().process_frame
@@ -429,7 +421,7 @@ func inject_mouse_drag(params: Dictionary) -> Dictionary:
 		supplied = _follow_in_the_window(at) or supplied
 		Input.parse_input_event(_motion(at, relative))
 	await _host.get_tree().process_frame
-	Input.parse_input_event(_button(end, button, false, false))
+	Input.parse_input_event(GdhMouse.button_event(end, button, false, false))
 	await _host.get_tree().process_frame
 
 	var said: Dictionary = _pointer_noted(
@@ -550,6 +542,7 @@ func click(params: Dictionary) -> Dictionary:
 	# other words, a link among them. Said either way, so a press on the middle is never read as one
 	# on the words.
 	var aim: Vector2 = control.size * 0.5
+	var at_centre: bool = true
 	var item_scrolled: bool = false
 	if item != null:
 		var found_by_words: Dictionary = found
@@ -559,6 +552,7 @@ func click(params: Dictionary) -> Dictionary:
 		if placed_item.has("message"):
 			return placed_item
 		aim = placed_item["point"]
+		at_centre = false
 		item_scrolled = placed_item["scrolled"]
 	var rich: RichTextLabel = control as RichTextLabel
 	if found != null and rich != null:
@@ -566,6 +560,7 @@ func click(params: Dictionary) -> Dictionary:
 		var found_here: Dictionary = found
 		if placed.has("point"):
 			aim = placed["point"]
+			at_centre = false
 			found_here["pressedOn"] = "the words"
 		elif placed.has("unplaced"):
 			found_here["pressedOn"] = "the middle of the label"
@@ -602,6 +597,20 @@ func click(params: Dictionary) -> Dictionary:
 			}
 		local = control.get_global_transform_with_canvas() * aim
 
+	# A control taller or wider than what shows it has its centre out of sight at every scroll, and
+	# a player clicks the part they can see. Refused, it was called a control nothing could click.
+	var on_part: bool = false
+	if at_centre and not _in_sight(control, own, local):
+		var part: Variant = GdhScreen.shown_part(control)
+		if part is Rect2:
+			var seen: Rect2 = part
+			var middle: Vector2 = seen.get_center()
+			# The box of a turned control is wider than the control, so its middle may be off it.
+			var back: Vector2 = control.get_global_transform_with_canvas().affine_inverse() * middle
+			if seen.has_area() and Rect2(Vector2.ZERO, control.size).has_point(back):
+				local = middle
+				on_part = true
+
 	var reached: Dictionary = GdhScreen.reach(own, local)
 	var viewport: Viewport = reached["viewport"]
 	var centre: Vector2 = reached["point"]
@@ -638,6 +647,8 @@ func click(params: Dictionary) -> Dictionary:
 	if hovered != null:
 		hovered_path = str(hovered.get_path())
 	var landed: bool = hovered == control or (hovered != null and control.is_ancestor_of(hovered))
+	# Asked only of a miss, before the press restacks windows: hovered missed a window over it.
+	var cover: Node = null if landed else GdhTargets.drawn_over(control)
 
 	# The link a rich label says was pressed, which is its own word for what the press reached.
 	var links: Array = []
@@ -653,9 +664,7 @@ func click(params: Dictionary) -> Dictionary:
 	var was_pressed: Variant = null
 	if toggle != null and toggle.toggle_mode:
 		was_pressed = toggle.button_pressed
-	_press_button(viewport, _button(position, button, true, double))
-	await _host.get_tree().process_frame
-	_press_button(viewport, _button(position, button, false, false))
+	var press: InputEventMouseButton = await _click_button(viewport, position, button, double)
 	# The release is what a button acts on, and a queue_free it causes lands at the end of
 	# this frame; the frame passes so the answer describes the control as the click left it.
 	await _host.get_tree().process_frame
@@ -675,9 +684,20 @@ func click(params: Dictionary) -> Dictionary:
 		"double": double,
 		"hovered": hovered_path,
 		"landed": landed,
+		"actions": GdhValues.actions_of(press),
 		"control_afterwards": afterwards,
 		"scrolled_into_view": scrolled,
 	}
+	if on_part:
+		answer["pressed_on"] = "the middle of the part on screen, since no scroll brings its centre into view"
+	# A Label and a TextureRect ignore the pointer unless told otherwise, so the click goes to what is
+	# under them, and landed false with that control as hovered said nothing of why.
+	if not landed and control.mouse_filter == Control.MOUSE_FILTER_IGNORE:
+		answer["why_not_landed"] = (
+			"%s's mouse_filter is ignore, so the pointer passes through it to what is under it" % node_path
+		)
+	elif cover != null:
+		answer["why_not_landed"] = "%s is drawn over it at the point clicked" % cover.get_path()
 	if found != null:
 		answer["found"] = found
 	if was_pressed != null:
@@ -718,7 +738,7 @@ func _takes_no_click(control: Control, node_path: String) -> String:
 			% [node_path, on]
 		)
 	if not control.can_process():
-		var why: String = _why_it_does_not_process(control, node_path)
+		var why: String = GdhTargets.why_it_does_not_process(control, node_path)
 		var over: Node = GdhTargets.drawn_over(control)
 		var cover: String = "" if over == null else "; %s is drawn over it" % over.get_path()
 		if _host.get_tree().paused:
@@ -730,23 +750,6 @@ func _takes_no_click(control: Control, node_path: String) -> String:
 	return ""
 
 
-## Which node's process_mode keeps [param control] from processing, and what it is. A node set to
-## inherit takes its parent's, so the one deciding can be any node above it: the game turning a
-## whole screen off while a menu shows over it reads, on the button, as a button turned off.
-static func _why_it_does_not_process(control: Control, node_path: String) -> String:
-	var deciding: Node = control
-	while deciding.process_mode == Node.PROCESS_MODE_INHERIT and deciding.get_parent() != null:
-		deciding = deciding.get_parent()
-	# The root inherits from nothing, which processes as pausable.
-	var value: int = deciding.process_mode
-	if value == Node.PROCESS_MODE_INHERIT:
-		value = Node.PROCESS_MODE_PAUSABLE
-	var mode: String = PROCESS_MODES.get(value, str(value))
-	if deciding == control:
-		return "its process_mode is %s" % mode
-	return "%s inherits process_mode %s from %s" % [node_path, mode, deciding.get_path()]
-
-
 ## Why a click at [param control]'s centre would reach nothing, or "" when it would reach it: the
 ## centre outside the viewport it is drawn in, at [param local]; outside the viewport showing that
 ## one on the screen, which [param reached] holds with the centre there; or clipped away by a
@@ -799,6 +802,23 @@ func _no_window_note(viewport: Viewport) -> String:
 ##
 ## Any other viewport is pushed into directly: Input reaches only the game's window. That is a
 ## viewport with no place on the screen, since `GdhScreen.reach` carries every other one there.
+## A press and its release a frame apart, answering with the press. A double click arrives as the
+## engine gets one from the system: a whole click, then a second press marked as a double click and
+## its release. Sent as the marked press alone, it pressed a button once where a player's presses it
+## twice.
+func _click_button(viewport: Viewport, position: Vector2, button: int, double: bool) -> InputEventMouseButton:
+	if double:
+		_press_button(viewport, GdhMouse.button_event(position, button, true, false))
+		await _host.get_tree().process_frame
+		_press_button(viewport, GdhMouse.button_event(position, button, false, false))
+		await _host.get_tree().process_frame
+	var press: InputEventMouseButton = GdhMouse.button_event(position, button, true, double)
+	_press_button(viewport, press)
+	await _host.get_tree().process_frame
+	_press_button(viewport, GdhMouse.button_event(position, button, false, false))
+	return press
+
+
 func _press_button(viewport: Viewport, event: InputEventMouseButton) -> void:
 	if viewport == _host.get_tree().root:
 		Input.parse_input_event(event)
@@ -881,9 +901,7 @@ func _click_in_the_world(node_path: String, item: Node3D, params: Dictionary) ->
 	var through: Dictionary = _through_the_interface(out)
 	var hovered_path: Variant = through["hovered"]
 
-	_press_button(arriving, _button(position, button, true, double))
-	await _host.get_tree().process_frame
-	_press_button(arriving, _button(position, button, false, false))
+	var _press: InputEventMouseButton = await _click_button(arriving, position, button, double)
 	await _host.get_tree().process_frame
 
 	return _pointer_noted(
@@ -979,18 +997,3 @@ func _motion(position: Vector2, relative: Vector2) -> InputEventMouseMotion:
 	event.screen_velocity = event.velocity
 	event.button_mask = Input.get_mouse_button_mask()
 	return event
-
-
-## A button event carries the buttons held once it has happened: the pressed one among them, the
-## released one out. A wheel step is a button with no mask, as it is from a real mouse.
-func _button(position: Vector2, button: int, pressed: bool, double: bool) -> InputEventMouseButton:
-	var event: InputEventMouseButton = InputEventMouseButton.new()
-	event.position = position
-	event.global_position = position
-	event.button_index = button as MouseButton
-	event.pressed = pressed
-	event.double_click = double
-	var held: int = Input.get_mouse_button_mask()
-	var own: int = GdhMouse.mask_of(button)
-	event.button_mask = (held | own) if pressed else (held & ~own)
-	return event

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

@@ -65,6 +65,23 @@ static func mask_of(button: int) -> int:
 	return 1 << (button - 1)
 
 
+## A button event carries the buttons held once it has happened: the pressed one among them, the
+## released one out. A wheel step is a button with no mask, as it is from a real mouse.
+static func button_event(
+	position: Vector2, button: int, pressed: bool, double: bool
+) -> InputEventMouseButton:
+	var event: InputEventMouseButton = InputEventMouseButton.new()
+	event.position = position
+	event.global_position = position
+	event.button_index = button as MouseButton
+	event.pressed = pressed
+	event.double_click = double
+	var held: int = Input.get_mouse_button_mask()
+	var own: int = mask_of(button)
+	event.button_mask = (held | own) if pressed else (held & ~own)
+	return event
+
+
 ## [param answer], saying so when one of [param points] lies outside [param viewport]: the GUI picks
 ## what is under the pointer only inside it, so such a press or motion reaches no control, and its
 ## answer read the same as one that landed.

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

@@ -68,16 +68,19 @@ func inject_joypad_button(params: Dictionary) -> Dictionary:
 		return {"type": "error", "message": holding}
 	var frames: int = holding
 
-	Input.parse_input_event(_button(button, device, whole or held))
+	var focused: String = GdhValues.focus_path(_host)
+	var event: InputEventJoypadButton = _button(button, device, whole or held)
+	Input.parse_input_event(event)
 	var lasted: Variant = null
 	if whole:
 		# A frame between the halves at least, as a key has, so a game that acts on the press and one
 		# that acts on the release each get a frame to do it in.
 		lasted = await GdhValues.hold(_host.get_tree(), frames)
 		Input.parse_input_event(_button(button, device, false))
-		await _host.get_tree().process_frame
+	# The engine hands a parsed event on at the next frame, so the focus is read after one.
+	await _host.get_tree().process_frame
 
-	return {
+	var answer: Dictionary = {
 		"type": "input_injected",
 		"input_type": "joypad_button",
 		"held_frames": GdhValues.held_answer(whole, frames),
@@ -85,9 +88,11 @@ func inject_joypad_button(params: Dictionary) -> Dictionary:
 		"button": button,
 		"button_name": _name_of(button, JOY_BUTTONS),
 		"device": device,
+		"actions": GdhValues.actions_of(event),
 		"pressed": held and not whole,
 		"whole": whole,
 	}
+	return GdhValues.focus_noted(answer, focused, _host)
 
 
 ## Moves a stick or trigger axis to a value, where it stays until another motion moves it, as a
@@ -110,16 +115,20 @@ func inject_joypad_motion(params: Dictionary) -> Dictionary:
 	event.axis = axis as JoyAxis
 	event.axis_value = value
 	event.device = device
+	var focused: String = GdhValues.focus_path(_host)
 	Input.parse_input_event(event)
+	await _host.get_tree().process_frame
 
-	return {
+	var answer: Dictionary = {
 		"type": "input_injected",
 		"input_type": "joypad_motion",
 		"axis": axis,
 		"axis_name": _name_of(axis, JOY_AXES),
 		"value": value,
 		"device": device,
+		"actions": GdhValues.actions_of(event),
 	}
+	return GdhValues.focus_noted(answer, focused, _host)
 
 
 static func _button(button: int, device: int, down: bool) -> InputEventJoypadButton: