fix: clarify analog trigger precision conflicts

Author: NSEvent

XboxControllerMapper/XboxControllerMapper/Models/JoystickSettings.swift

@@ -49,6 +49,10 @@ enum AnalogPrecisionTriggerMode: String, Codable, CaseIterable {
     case right = "right"
     case either = "either"
 
+	static var allCases: [AnalogPrecisionTriggerMode] {
+		[.off, .right, .left, .either]
+	}
+
     var displayName: String {
 		switch self {
 		case .off: return "Off"

XboxControllerMapper/XboxControllerMapper/Views/MainWindow/SettingsViews.swift

@@ -193,6 +193,14 @@ struct JoystickSettingsView: View {
 					}
 				}
 				.pickerStyle(.segmented)
+				.help("R2 / RT avoids the left-trigger swipe-typing overlap.")
+
+				if let analogPrecisionWarning {
+					Label(analogPrecisionWarning, systemImage: "exclamationmark.triangle")
+						.font(.caption)
+						.foregroundStyle(.secondary)
+						.help(analogPrecisionWarning)
+				}
 
 				if settings.analogPrecisionTriggerMode != .off {
 					SliderRow(
@@ -402,6 +410,40 @@ struct JoystickSettingsView: View {
         profileManager.updateJoystickSettings(newSettings)
     }
 
+	private var analogPrecisionTriggerButtons: [ControllerButton] {
+		switch settings.analogPrecisionTriggerMode {
+		case .off:
+			return []
+		case .left:
+			return [.leftTrigger]
+		case .right:
+			return [.rightTrigger]
+		case .either:
+			return [.rightTrigger, .leftTrigger]
+		}
+	}
+
+	private var analogPrecisionWarning: String? {
+		guard !analogPrecisionTriggerButtons.isEmpty else { return nil }
+		var messages: [String] = []
+
+		if let profile = profileManager.activeProfile {
+			let mappedTriggers = analogPrecisionTriggerButtons.filter { button in
+				(profile.buttonMappings[button]?.isEmpty == false)
+			}
+			if !mappedTriggers.isEmpty {
+				let names = mappedTriggers.map(\.displayName).joined(separator: " / ")
+				messages.append("\(names) also has a button mapping; precision stacks with that action.")
+			}
+		}
+
+		if analogPrecisionTriggerButtons.contains(.leftTrigger) {
+			messages.append("LT also starts swipe typing while the on-screen keyboard is visible.")
+		}
+
+		return messages.isEmpty ? nil : messages.joined(separator: " ")
+	}
+
     /// The layer whose overrides are being edited: the picked one, or the first layer
     /// when nothing valid is selected (so the section always shows a layer).
     private func resolvedOverrideLayer(_ layers: [Layer]) -> Layer? {

XboxControllerMapper/XboxControllerMapperTests/JoystickAndMouseMappingTests.swift

@@ -27,6 +27,52 @@ final class JoystickAndMouseMappingTests: MappingEngineTestCase {
             }, "Mouse movement should be generated from joystick input")
         }
     }
+
+	func testAnalogPrecisionTriggerScalesJoystickMouseMovement() async throws {
+		await MainActor.run {
+			var settings = JoystickSettings()
+			settings.leftStick.mode = .mouse
+			settings.leftStick.mouseDeadzone = 0.05
+			settings.leftStick.mouseAcceleration = 0.0
+			settings.leftStick.mouseSensitivity = 0.5
+			settings.analogPrecisionTriggerMode = .right
+			settings.analogPrecisionMinimumSpeed = 0.25
+			settings.analogPrecisionDeadzone = 0.0
+			settings.analogPrecisionCurve = 0.0
+
+			let profile = Profile(name: "Analog Precision", buttonMappings: [:], joystickSettings: settings)
+			profileManager.setActiveProfile(profile)
+			controllerService.isConnected = true
+		}
+		await waitForTasks(0.15)
+
+		controllerService.updateRightTrigger(0.0, pressed: false)
+		mockInputSimulator.clearEvents()
+		controllerService.setLeftStickForTesting(CGPoint(x: 0.8, y: 0.0))
+		await waitForTasks(0.35)
+		let normal = averageRecentMouseDeltaX()
+
+		controllerService.updateRightTrigger(1.0, pressed: false)
+		mockInputSimulator.clearEvents()
+		await waitForTasks(0.35)
+		let precise = averageRecentMouseDeltaX()
+
+		XCTAssertGreaterThan(normal, 0.1)
+		XCTAssertGreaterThan(precise, 0.1)
+		XCTAssertLessThan(precise, normal * 0.6)
+	}
+
+	private func averageRecentMouseDeltaX(limit: Int = 8) -> CGFloat {
+		let deltas = mockInputSimulator.events.compactMap { event -> CGFloat? in
+			if case .moveMouse(let dx, _) = event {
+				return abs(dx)
+			}
+			return nil
+		}
+		let recent = Array(deltas.suffix(limit))
+		XCTAssertFalse(recent.isEmpty, "Expected mouse movement events")
+		return recent.reduce(0, +) / CGFloat(max(recent.count, 1))
+	}
 
     // MARK: - Joystick Processing Tests (High Priority)
 

XboxControllerMapper/XboxControllerMapperTests/MappingEngineTouchpadCoverageTests.swift

@@ -117,6 +117,52 @@ final class MappingEngineTouchpadCoverageTests: XCTestCase {
         }
     }
 
+	func testAnalogPrecisionTriggerScalesTouchpadMouseMovement() async throws {
+		await MainActor.run {
+			var profile = Profile(name: "TouchAnalogPrecision", buttonMappings: [:])
+			profile.joystickSettings.touchpadDeadzone = 0.00001
+			profile.joystickSettings.touchpadSmoothing = 0
+			profile.joystickSettings.analogPrecisionTriggerMode = .right
+			profile.joystickSettings.analogPrecisionMinimumSpeed = 0.25
+			profile.joystickSettings.analogPrecisionDeadzone = 0.0
+			profile.joystickSettings.analogPrecisionCurve = 0.0
+			profileManager.setActiveProfile(profile)
+		}
+		try? await Task.sleep(nanoseconds: 10_000_000)
+
+		await MainActor.run {
+			controllerService.updateRightTrigger(0.0, pressed: false)
+			mockInputSimulator.clearEvents()
+			controllerService.emitInputEvent(.touchpadMoved(CGPoint(x: 0.6, y: 0.4)))
+		}
+		await waitForTasks(0.2)
+		let normal = averageRecentTouchpadMouseMagnitude()
+
+		await MainActor.run {
+			controllerService.updateRightTrigger(1.0, pressed: false)
+			mockInputSimulator.clearEvents()
+			controllerService.emitInputEvent(.touchpadMoved(CGPoint(x: 0.6, y: 0.4)))
+		}
+		await waitForTasks(0.2)
+		let precise = averageRecentTouchpadMouseMagnitude()
+
+		XCTAssertGreaterThan(normal, 0.1)
+		XCTAssertGreaterThan(precise, 0.1)
+		XCTAssertLessThan(precise, normal * 0.6)
+	}
+
+	private func averageRecentTouchpadMouseMagnitude(limit: Int = 4) -> CGFloat {
+		let magnitudes = mockInputSimulator.events.compactMap { event -> CGFloat? in
+			if case .moveMouse(let dx, let dy) = event {
+				return hypot(dx, dy)
+			}
+			return nil
+		}
+		let recent = Array(magnitudes.suffix(limit))
+		XCTAssertFalse(recent.isEmpty, "Expected touchpad mouse movement events")
+		return recent.reduce(0, +) / CGFloat(max(recent.count, 1))
+	}
+
     func testTouchpadMovementSuppressedDuringTwoFingerGesture() async throws {
         await MainActor.run {
             var profile = Profile(name: "TouchSuppressed", buttonMappings: [:])