From 57287fd41ac35089500af05e1241c212d55f14c6 Mon Sep 17 00:00:00 2001
From: wuhu <wuhu@cuicuilideMac-mini.local>
Date: Wed, 6 May 2026 21:27:23 +0800
Subject: [PATCH 01/10] =?UTF-8?q?fix:=20preserve=20mouse=20button=20bindin?=
 =?UTF-8?q?gs=20in=20ChildButton=20/=20=E4=BF=AE=E5=A4=8D=20ChildButton=20?=
 =?UTF-8?q?=E9=BC=A0=E6=A0=87=E6=8C=89=E9=94=AE=E7=BB=91=E5=AE=9A=E4=BF=9D?=
 =?UTF-8?q?=E5=AD=98=E9=94=99=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Elements/Instances/ChildButton.swift           | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/PlayTools/Editor/Controllers/Elements/Instances/ChildButton.swift b/PlayTools/Editor/Controllers/Elements/Instances/ChildButton.swift
index 2b216863..226b0b9b 100644
--- a/PlayTools/Editor/Controllers/Elements/Instances/ChildButton.swift
+++ b/PlayTools/Editor/Controllers/Elements/Instances/ChildButton.swift
@@ -27,8 +27,18 @@ class ChildButtonModel: ControlModel<Button> {
 
     override func setKey(code: Int, name: String) {
         var buttonData = data
-        buttonData.keyCode = code
-        buttonData.keyName = name
+
+        if code != KeyCodeNames.defaultCode {
+            buttonData.keyCode = code
+            buttonData.keyName = KeyCodeNames.keyCodes[code] ?? name
+        } else if let resolvedCode = KeyCodeNames.keyCodeByName[name] {
+            buttonData.keyCode = resolvedCode
+            buttonData.keyName = name
+        } else {
+            buttonData.keyCode = code
+            buttonData.keyName = name
+        }
+
         data = buttonData
         button.setTitle(data.keyName, for: UIControl.State.normal)
     }

From 1541d120ba89de4fd1830a952036accd1d636adf Mon Sep 17 00:00:00 2001
From: wuhu <wuhu@cuicuilideMac-mini.local>
Date: Wed, 6 May 2026 21:27:39 +0800
Subject: [PATCH 02/10] =?UTF-8?q?feat:=20add=20controller=20aliases=20and?=
 =?UTF-8?q?=20thumbstick=20drag=20support=20/=20=E6=96=B0=E5=A2=9E?=
 =?UTF-8?q?=E6=89=8B=E6=9F=84=E5=88=AB=E5=90=8D=E6=98=A0=E5=B0=84=E4=B8=8E?=
 =?UTF-8?q?=E6=91=87=E6=9D=86=E6=8B=96=E6=8B=BD=E6=94=AF=E6=8C=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Controls/Backend/Action/PlayAction.swift  | 24 +++---
 .../Elements/Instances/Joystick.swift         |  4 +-
 .../Elements/Instances/MouseArea.swift        |  2 +-
 PlayTools/Keymap/KeyCodeNames.swift           | 78 +++++++++++++++----
 4 files changed, 83 insertions(+), 25 deletions(-)

diff --git a/PlayTools/Controls/Backend/Action/PlayAction.swift b/PlayTools/Controls/Backend/Action/PlayAction.swift
index dcf09297..4a5b5c8b 100644
--- a/PlayTools/Controls/Backend/Action/PlayAction.swift
+++ b/PlayTools/Controls/Backend/Action/PlayAction.swift
@@ -27,9 +27,13 @@ class ButtonAction: Action {
         self.keyName = keyName
         self.point = point
         let code = keyCode
-        let codeName = KeyCodeNames.keyCodes[code] ?? "Btn"
         // TODO: set both key names in draggable button, so as to depracate key code
-        ActionDispatcher.register(key: code == KeyCodeNames.defaultCode ? keyName: codeName, handler: self.update)
+        let keys = code == KeyCodeNames.defaultCode ?
+            [keyName] :
+            KeyCodeNames.dispatchNames(for: code, fallback: keyName)
+        for key in keys {
+            ActionDispatcher.register(key: key, handler: self.update)
+        }
     }
 
     convenience init(data: Button) {
@@ -66,18 +70,18 @@ class DraggableButtonAction: ButtonAction {
             Toucher.touchcam(point: point, phase: UITouch.Phase.began, tid: &id,
                              actionName: "DraggableButton", keyName: keyName)
             self.releasePoint = point
-            ActionDispatcher.register(key: KeyCodeNames.mouseMove,
+            ActionDispatcher.register(key: keyName,
                                       handler: self.onMouseMoved,
                                       priority: .DRAGGABLE)
-            if !mode.cursorHidden() {
+            if keyName == KeyCodeNames.mouseMove && !mode.cursorHidden() {
                 AKInterface.shared!.hideCursor()
             }
         } else {
             Toucher.touchcam(point: releasePoint, phase: UITouch.Phase.ended, tid: &id,
                              actionName: "DraggableButton", keyName: keyName)
             if id == nil {
-                ActionDispatcher.unregister(key: KeyCodeNames.mouseMove)
-                if !mode.cursorHidden() {
+                ActionDispatcher.unregister(key: keyName)
+                if keyName == KeyCodeNames.mouseMove && !mode.cursorHidden() {
                     AKInterface.shared!.unhideCursor()
                 }
             }
@@ -85,7 +89,7 @@ class DraggableButtonAction: ButtonAction {
     }
 
     override func invalidate() {
-        ActionDispatcher.unregister(key: KeyCodeNames.mouseMove)
+        ActionDispatcher.unregister(key: keyName)
         super.invalidate()
     }
 
@@ -189,8 +193,10 @@ class JoystickAction: Action {
         self.mode = mode
         for index in 0..<keys.count {
             let key = keys[index]
-            ActionDispatcher.register(key: KeyCodeNames.keyCodes[key]!,
-                                     handler: self.getPressedHandler(index: index))
+            for keyName in KeyCodeNames.dispatchNames(for: key) {
+                ActionDispatcher.register(key: keyName,
+                                         handler: self.getPressedHandler(index: index))
+            }
         }
     }
 
diff --git a/PlayTools/Editor/Controllers/Elements/Instances/Joystick.swift b/PlayTools/Editor/Controllers/Elements/Instances/Joystick.swift
index 642a1700..4e4f9336 100644
--- a/PlayTools/Editor/Controllers/Elements/Instances/Joystick.swift
+++ b/PlayTools/Editor/Controllers/Elements/Instances/Joystick.swift
@@ -77,7 +77,7 @@ class JoystickModel: ControlModel<Joystick>, ParentElement {
             return
         }
         // `name` here may be "btn", "W", "RMB" etc.
-        if name.hasSuffix("tick") {
+        if KeyCodeNames.isThumbstick(name) {
             // Mapping a thumbstick joystick
             self.data.keyName = name
             btn.setKey(showChild: false, name: data.keyName)
@@ -115,6 +115,6 @@ class JoystickModel: ControlModel<Joystick>, ParentElement {
         // possible values are
         // ["Left Thumbstick", "Right Thumbstick", "Mouse", "Keyboard", "Dynamic"]
         // Where the former three are analog
-        data.keyName.contains(Character("u"))
+        data.keyName == KeyCodeNames.mouseMove || KeyCodeNames.isThumbstick(data.keyName)
     }
 }
diff --git a/PlayTools/Editor/Controllers/Elements/Instances/MouseArea.swift b/PlayTools/Editor/Controllers/Elements/Instances/MouseArea.swift
index cda2f0e0..f976712f 100644
--- a/PlayTools/Editor/Controllers/Elements/Instances/MouseArea.swift
+++ b/PlayTools/Editor/Controllers/Elements/Instances/MouseArea.swift
@@ -22,7 +22,7 @@ class MouseAreaModel: ControlModel<MouseArea> {
 
     override func setKey(code: Int, name: String) {
         if code < 0 {
-            if name.hasSuffix("tick") {
+            if KeyCodeNames.isThumbstick(name) {
                 self.data.keyName = name
             } else {
                 self.data.keyName = "Mouse"
diff --git a/PlayTools/Keymap/KeyCodeNames.swift b/PlayTools/Keymap/KeyCodeNames.swift
index e11cfc11..2960e96f 100644
--- a/PlayTools/Keymap/KeyCodeNames.swift
+++ b/PlayTools/Keymap/KeyCodeNames.swift
@@ -14,19 +14,22 @@ class KeyCodeNames {
     public static let fakeMouse = "FakeMouse"
 
     private static let gcKeyCodeLiteral = [
-    -4: "cA",
-    -5: "cX",
-    -6: "cB",
-    -7: "cY",
-    -8: "dU",
-    -9: "dD",
-//    -10: "dR",
+    -4: "Button A",
+    -5: "Button X",
+    -6: "Button B",
+    -7: "Button Y",
+    -8: "Direction Pad Up",
+    -9: "Direction Pad Down",
+//    -10: "Direction Pad Right",
     -10: "Controller",
-    -11: "dL",
-    -12: "L1",
-    -13: "L2",
-    -14: "R1",
-    -15: "R2",
+    -11: "Direction Pad Left",
+    -12: "Left Shoulder",
+    -13: "Left Trigger",
+    -14: "Right Shoulder",
+    -15: "Right Trigger",
+    -16: "Direction Pad Right",
+    -17: "Button Menu",
+    -18: "Button Options",
     -1: "LMB",
     -2: "RMB",
     -3: "MMB",
@@ -153,6 +156,55 @@ class KeyCodeNames {
         gcCode[GCKeyCode.pageDown.rawValue] = "Page Down"
         return gcCode
     }()
+
+    private static let controllerKeyAliases: [Int: [String]] = [
+        -4: ["Button A", "cA"],
+        -5: ["Button X", "cX"],
+        -6: ["Button B", "cB"],
+        -7: ["Button Y", "cY"],
+        -8: ["Direction Pad Up", "dU"],
+        -9: ["Direction Pad Down", "dD"],
+        -11: ["Direction Pad Left", "dL"],
+        -12: ["Left Shoulder", "L1"],
+        -13: ["Left Trigger", "L2"],
+        -14: ["Right Shoulder", "R1"],
+        -15: ["Right Trigger", "R2"],
+        -16: ["Direction Pad Right", "dR"],
+        -17: ["Button Menu"],
+        -18: ["Button Options"]
+    ]
+
+    public static let keyCodeByName: [String: Int] = {
+        var names = [String: Int]()
+        for (code, name) in keyCodes {
+            names[name] = code
+        }
+        for (code, aliases) in controllerKeyAliases {
+            for alias in aliases {
+                names[alias] = code
+            }
+        }
+        return names
+    }()
+
+    public static func dispatchNames(for code: Int, fallback: String? = nil) -> [String] {
+        var names = [String]()
+        if let name = keyCodes[code] {
+            names.append(name)
+        }
+        if let aliases = controllerKeyAliases[code] {
+            names.append(contentsOf: aliases)
+        }
+        if let fallback = fallback {
+            names.append(fallback)
+        }
+        var seen = Set<String>()
+        return names.filter { seen.insert($0).inserted }
+    }
+
+    public static func isThumbstick(_ name: String) -> Bool {
+        name == "Left Thumbstick" || name == "Right Thumbstick"
+    }
 }
 // Swift lint said the class was too long, so split into two parts
 extension KeyCodeNames {
@@ -281,7 +333,7 @@ extension KeyCodeNames {
         mapVirtualToGc[117] = GCKeyCode.deleteForward.rawValue
         mapVirtualToGc[119] = GCKeyCode.end.rawValue
         mapVirtualToGc[121] = GCKeyCode.pageDown.rawValue
-        assert(keyCodes.count - 15 == mapVirtualToGc.count)
+        assert(keyCodes.count - 18 == mapVirtualToGc.count)
         return mapVirtualToGc
     }()
 }// Swift lint said the file was too long so removing the unused reverse mapping

From 4e6e09bb5454b60bc0ea529ec4c2621b4b59d76d Mon Sep 17 00:00:00 2001
From: wqf <wukingfen@gmail.com>
Date: Mon, 11 May 2026 00:13:11 +0800
Subject: [PATCH 03/10] =?UTF-8?q?feat:=20add=20UI=20support=20for=20button?=
 =?UTF-8?q?=20modifier=20combos=20/=20=E6=96=B0=E5=A2=9E=E6=8C=89=E9=92=AE?=
 =?UTF-8?q?=E7=BB=84=E5=90=88=E9=94=AE=20UI=20=E6=94=AF=E6=8C=81?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 PlayTools/Controls/ActionDispatcher.swift     | 40 +++++++++--
 .../Controls/Backend/Action/PlayAction.swift  | 68 ++++++++++++++++---
 PlayTools/Controls/MenuController.swift       | 41 +++++++++--
 .../Editor/Controllers/EditorController.swift | 49 ++++++++++++-
 .../Elements/ElementController.swift          |  9 +++
 .../Elements/Instances/Button.swift           | 36 +++++++++-
 .../Editor/Models/Elements/Element.swift      |  2 +
 7 files changed, 222 insertions(+), 23 deletions(-)

diff --git a/PlayTools/Controls/ActionDispatcher.swift b/PlayTools/Controls/ActionDispatcher.swift
index 000cf1a1..dae3e11d 100644
--- a/PlayTools/Controls/ActionDispatcher.swift
+++ b/PlayTools/Controls/ActionDispatcher.swift
@@ -20,7 +20,8 @@ public enum ActionDispatchPriority: Int {
 public class ActionDispatcher {
     static private let keymapVersion = "2.0."
     static private var actions = [Action]()
-    static private var buttonHandlers: [String: [(Bool) -> Void]] = [:]
+    static private var buttonHandlers: [String: [ButtonPressHandler]] = [:]
+    static private var pressedKeys = Set<String>()
 
     static private let priorityCount = 3
     // You can't put more than 8 cameras or 8 joysticks in a keymap right?
@@ -35,6 +36,7 @@ public class ActionDispatcher {
         invalidateActions()
         actions = []
         buttonHandlers.removeAll(keepingCapacity: true)
+        pressedKeys.removeAll(keepingCapacity: true)
         directionPadHandlers.forEach({ handlers in
             handlers.forEach({ handler in
                 handler.store(.EMPTY, ordering: .relaxed)
@@ -96,11 +98,17 @@ public class ActionDispatcher {
     }
 
     static public func register(key: String, handler: @escaping (Bool) -> Void) {
+        register(key: key, modifierKeys: [], handler: handler)
+    }
+
+    static public func register(key: String,
+                                modifierKeys: [String],
+                                handler: @escaping (Bool) -> Void) {
         // this function is called when setting up `button` type of mapping
         if buttonHandlers[key] == nil {
             buttonHandlers[key] = []
         }
-        buttonHandlers[key]!.append(handler)
+        buttonHandlers[key]!.append(ButtonPressHandler(modifierKeys: modifierKeys, handle: handler))
     }
 
     static public func register(key: String,
@@ -188,18 +196,31 @@ public class ActionDispatcher {
     }
 
     static public func dispatch(key: String, pressed: Bool) -> Bool {
+        if pressed {
+            pressedKeys.insert(key)
+        } else {
+            pressedKeys.remove(key)
+        }
         guard let handlers = buttonHandlers[key] else {
             return false
         }
-        var mapped = false
-        for handler in handlers {
+        let modifiedHandlers = handlers.filter { handler in
+            !handler.modifierKeys.isEmpty && isPressed(anyOf: handler.modifierKeys)
+        }
+        let selectedHandlers = modifiedHandlers.isEmpty ?
+            handlers.filter { $0.modifierKeys.isEmpty } :
+            modifiedHandlers
+        for handler in selectedHandlers {
             PlayInput.touchQueue.async(qos: .userInteractive, execute: {
-                handler(pressed)
+                handler.handle(pressed)
             })
-            mapped = true
         }
         // return value matters. A false value makes a beep sound
-        return mapped
+        return !selectedHandlers.isEmpty
+    }
+
+    static public func isPressed(anyOf keys: [String]) -> Bool {
+        keys.contains { pressedKeys.contains($0) }
     }
 
     static public func dispatch(key: String, valueX: CGFloat, valueY: CGFloat) -> Bool {
@@ -217,6 +238,11 @@ public class ActionDispatcher {
     }
 }
 
+private struct ButtonPressHandler {
+    let modifierKeys: [String]
+    let handle: (Bool) -> Void
+}
+
 private final class AtomicHandler: AtomicReference {
     static fileprivate let EMPTY = AtomicHandler("", {_, _ in })
     let key: String
diff --git a/PlayTools/Controls/Backend/Action/PlayAction.swift b/PlayTools/Controls/Backend/Action/PlayAction.swift
index 4a5b5c8b..03385467 100644
--- a/PlayTools/Controls/Backend/Action/PlayAction.swift
+++ b/PlayTools/Controls/Backend/Action/PlayAction.swift
@@ -13,26 +13,37 @@ protocol Action {
 
 class ButtonAction: Action {
     func invalidate() {
+        isPressed = false
         Toucher.touchcam(point: point, phase: UITouch.Phase.ended, tid: &id,
                          actionName: "Button", keyName: keyName)
     }
 
     let keyCode: Int
     let keyName: String
+    let modifierKeyCode: Int?
+    let modifierKeyName: String?
+    private let modifierKeys: [String]
     let point: CGPoint
     var id: Int?
+    private var isPressed = false
 
-    init(keyCode: Int, keyName: String, point: CGPoint) {
+    init(keyCode: Int,
+         keyName: String,
+         modifierKeyCode: Int? = nil,
+         modifierKeyName: String? = nil,
+         point: CGPoint) {
         self.keyCode = keyCode
         self.keyName = keyName
+        self.modifierKeyCode = modifierKeyCode
+        self.modifierKeyName = modifierKeyName
+        self.modifierKeys = Self.dispatchNames(code: modifierKeyCode, name: modifierKeyName)
         self.point = point
-        let code = keyCode
         // TODO: set both key names in draggable button, so as to depracate key code
-        let keys = code == KeyCodeNames.defaultCode ?
-            [keyName] :
-            KeyCodeNames.dispatchNames(for: code, fallback: keyName)
-        for key in keys {
-            ActionDispatcher.register(key: key, handler: self.update)
+        for key in Self.dispatchNames(code: keyCode, name: keyName) {
+            ActionDispatcher.register(key: key, modifierKeys: modifierKeys, handler: self.update)
+        }
+        for key in modifierKeys {
+            ActionDispatcher.register(key: key, handler: self.updateModifier)
         }
     }
 
@@ -41,6 +52,8 @@ class ButtonAction: Action {
         self.init(
             keyCode: keyCode,
             keyName: data.keyName,
+            modifierKeyCode: data.modifierKeyCode,
+            modifierKeyName: data.modifierKeyName,
             point: CGPoint(
                 x: data.transform.xCoord.absoluteX,
                 y: data.transform.yCoord.absoluteY))
@@ -48,21 +61,58 @@ class ButtonAction: Action {
 
     func update(pressed: Bool) {
         if pressed {
+            guard !isPressed else {
+                return
+            }
+            isPressed = true
             Toucher.touchcam(point: point, phase: UITouch.Phase.began, tid: &id,
                              actionName: "Button", keyName: keyName)
         } else {
+            guard isPressed else {
+                return
+            }
+            isPressed = false
+            Toucher.touchcam(point: point, phase: UITouch.Phase.ended, tid: &id,
+                             actionName: "Button", keyName: keyName)
+        }
+    }
+
+    private func updateModifier(pressed: Bool) {
+        if !pressed && id != nil {
+            isPressed = false
             Toucher.touchcam(point: point, phase: UITouch.Phase.ended, tid: &id,
                              actionName: "Button", keyName: keyName)
         }
     }
+
+    private static func dispatchNames(code: Int?, name: String?) -> [String] {
+        guard let name = name, !name.isEmpty else {
+            return []
+        }
+
+        let resolvedCode = KeyCodeNames.keyCodeByName[name] ?? code
+        if let resolvedCode = resolvedCode, resolvedCode != KeyCodeNames.defaultCode {
+            return KeyCodeNames.dispatchNames(for: resolvedCode, fallback: name)
+        }
+        return [name]
+    }
 }
 
 class DraggableButtonAction: ButtonAction {
     var releasePoint: CGPoint
 
-    override init(keyCode: Int, keyName: String, point: CGPoint) {
+    override init(keyCode: Int,
+                  keyName: String,
+                  modifierKeyCode: Int? = nil,
+                  modifierKeyName: String? = nil,
+                  point: CGPoint) {
         self.releasePoint = point
-        super.init(keyCode: keyCode, keyName: keyName, point: point)
+        super.init(
+            keyCode: keyCode,
+            keyName: keyName,
+            modifierKeyCode: modifierKeyCode,
+            modifierKeyName: modifierKeyName,
+            point: point)
     }
 
     override func update(pressed: Bool) {
diff --git a/PlayTools/Controls/MenuController.swift b/PlayTools/Controls/MenuController.swift
index 6d734d1e..c60b7c8f 100644
--- a/PlayTools/Controls/MenuController.swift
+++ b/PlayTools/Controls/MenuController.swift
@@ -45,6 +45,16 @@ extension UIApplication {
         EditorController.shared.focusedControl?.resize(down: true)
     }
 
+    @objc
+    func captureElementModifierKey(_ sender: AnyObject) {
+        EditorController.shared.captureModifierKey()
+    }
+
+    @objc
+    func clearElementModifierKey(_ sender: AnyObject) {
+        EditorController.shared.clearModifierKey()
+    }
+
     // put a mark in the toucher log, so as to align with tester description
     @objc
     func markToucherLog(_ sender: AnyObject) {
@@ -141,6 +151,10 @@ var keymapping = [
                       value: "Upsize selected element", comment: ""),
     NSLocalizedString("menu.keymapping.downsizeElement", tableName: "Playtools",
                       value: "Downsize selected element", comment: ""),
+    NSLocalizedString("menu.keymapping.captureModifier", tableName: "Playtools",
+                      value: "Set selected button modifier", comment: ""),
+    NSLocalizedString("menu.keymapping.clearModifier", tableName: "Playtools",
+                      value: "Clear selected button modifier", comment: ""),
     NSLocalizedString("menu.keymapping.toggleDebug", tableName: "Playtools",
                       value: "Toggle Debug Overlay", comment: ""),
     NSLocalizedString("menu.keymapping.hide.pointer", tableName: "Playtools",
@@ -155,7 +169,8 @@ var iconsSelctor = [
     UIImage(systemName: "trash.fill"),
     UIImage(systemName: "square.resize.up"),
     UIImage(systemName: "square.resize.down"),
-    UIImage(systemName: "rectangle.landscape.rotate"),
+    UIImage(systemName: "command"),
+    UIImage(systemName: "command.circle"),
     UIImage(systemName: "wrench.and.screwdriver"),
     UIImage(systemName: "pointer.arrow.slash"),
     UIImage(systemName: "arrow.down.square"),
@@ -165,7 +180,8 @@ var keymappingSelectors = [#selector(UIApplication.switchEditorMode(_:)),
                            #selector(UIApplication.removeElement(_:)),
                            #selector(UIApplication.upscaleElement(_:)),
                            #selector(UIApplication.downscaleElement(_:)),
-                           #selector(UIApplication.rotateView(_:)),
+                           #selector(UIApplication.captureElementModifierKey(_:)),
+                           #selector(UIApplication.clearElementModifierKey(_:)),
                            #selector(UIApplication.toggleDebugOverlay(_:)),
                            #selector(UIApplication.hideCursor(_:)),
                            #selector(UIApplication.previousKeymap(_:)),
@@ -235,17 +251,32 @@ class MenuController {
             UIKeyCommand.inputDelete,       // Remove keymap element
             UIKeyCommand.inputUpArrow,      // Increase keymap element size
             UIKeyCommand.inputDownArrow,    // Decrease keymap element size
+            "M",                            // Set button modifier
+            "M",                            // Clear button modifier
             "D",                            // Toggle debug overlay
             ".",                            // Hide cursor until move
             "[",                            // Previous keymap
             "]"                             // Next keymap
         ]
-        let arrowKeyChildrenCommands = zip(zip(keyCommands, keymapping), iconsSelctor).map { (arg0, image) in
-            let (command, btn) = arg0
+        let keyModifiers: [UIKeyModifierFlags] = [
+            .command,
+            .command,
+            .command,
+            .command,
+            .command,
+            [.command, .shift],
+            .command,
+            .command,
+            .command,
+            .command
+        ]
+        let arrowKeyChildrenCommands = zip(zip(zip(keyCommands, keymapping), iconsSelctor), keyModifiers)
+            .map { (arg0, modifierFlags) in
+            let ((command, btn), image) = arg0
             return UIKeyCommand(title: btn, image: image,
                          action: keymappingSelectors[keymapping.firstIndex(of: btn)!],
                          input: command,
-                         modifierFlags: .command,
+                         modifierFlags: modifierFlags,
                          propertyList: [CommandsList.KeymappingToolbox: btn]
             )
         }
diff --git a/PlayTools/Editor/Controllers/EditorController.swift b/PlayTools/Editor/Controllers/EditorController.swift
index c950124f..d80569a7 100644
--- a/PlayTools/Editor/Controllers/EditorController.swift
+++ b/PlayTools/Editor/Controllers/EditorController.swift
@@ -7,9 +7,15 @@ class EditorController {
 
     static let shared = EditorController()
 
+    private enum KeyCaptureMode {
+        case primary
+        case modifier
+    }
+
     let lock = NSLock()
 
     var focusedControl: ControlElement?
+    private var keyCaptureMode = KeyCaptureMode.primary
 
     var editorWindow: UIWindow?
     weak var previousWindow: UIWindow?
@@ -38,6 +44,7 @@ class EditorController {
         if let mod = button.model {
             mod.focus(true)
             focusedControl = mod
+            keyCaptureMode = .primary
         }
     }
 
@@ -53,6 +60,7 @@ class EditorController {
             editorWindow = nil
             previousWindow?.makeKeyAndVisible()
             focusedControl = nil
+            keyCaptureMode = .primary
             Toast.showHint(title: NSLocalizedString("hint.keymapSaved",
                                                     tableName: "Playtools", value: "Keymap Saved", comment: ""))
         } else {
@@ -76,12 +84,22 @@ class EditorController {
 
     public func setKey(_ code: Int) {
         if editorMode {
-            focusedControl?.setKey(code: code)
+            if keyCaptureMode == .modifier {
+                focusedControl?.setModifierKey(code: code)
+                finishModifierCapture()
+            } else {
+                focusedControl?.setKey(code: code)
+            }
         }
     }
 
     public func setKey(_ name: String) {
         if editorMode {
+            if keyCaptureMode == .modifier {
+                focusedControl?.setModifierKey(name: name)
+                finishModifierCapture()
+                return
+            }
             if name != "Mouse" || focusedControl is MouseAreaModel
                 || focusedControl is JoystickModel
                 || focusedControl is DraggableButtonModel {
@@ -90,7 +108,36 @@ class EditorController {
         }
     }
 
+    public func captureModifierKey() {
+        guard editorMode, focusedControl is ButtonModel else {
+            Toast.showHint(title: "Select a button first",
+                           text: ["Select a button mapping, then press ⌘M to set its modifier key."])
+            return
+        }
+        keyCaptureMode = .modifier
+        Toast.showHint(title: "Press modifier key",
+                       text: ["The next keyboard, mouse, or controller button will become the modifier."])
+    }
+
+    public func clearModifierKey() {
+        guard editorMode, focusedControl is ButtonModel else {
+            Toast.showHint(title: "Select a button first",
+                           text: ["Select a button mapping, then press ⌘⇧M to clear its modifier key."])
+            return
+        }
+        focusedControl?.clearModifierKey()
+        keyCaptureMode = .primary
+        Toast.showHint(title: "Modifier cleared")
+    }
+
+    private func finishModifierCapture() {
+        keyCaptureMode = .primary
+        Toast.showHint(title: "Modifier set",
+                       text: ["Press another key to change the button's main binding."])
+    }
+
     public func removeControl() {
+        keyCaptureMode = .primary
         controls = controls.filter { $0 !== focusedControl }
         focusedControl?.remove()
     }
diff --git a/PlayTools/Editor/Controllers/Elements/ElementController.swift b/PlayTools/Editor/Controllers/Elements/ElementController.swift
index a289d2d4..ba4e20f5 100644
--- a/PlayTools/Editor/Controllers/Elements/ElementController.swift
+++ b/PlayTools/Editor/Controllers/Elements/ElementController.swift
@@ -13,6 +13,9 @@ protocol ControlElement: AnyObject {
     func focus(_ focus: Bool)
     func setKey(code: Int)
     func setKey(name: String)
+    func setModifierKey(code: Int)
+    func setModifierKey(name: String)
+    func clearModifierKey()
     func resize(down: Bool)
     func remove()
 }
@@ -71,4 +74,10 @@ class ControlModel<ElementType: BaseElement>: ControlElement {
     func setKey(name: String) {
         self.setKey(code: KeyCodeNames.defaultCode, name: name)
     }
+
+    func setModifierKey(code: Int) {}
+
+    func setModifierKey(name: String) {}
+
+    func clearModifierKey() {}
 }
diff --git a/PlayTools/Editor/Controllers/Elements/Instances/Button.swift b/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
index 4e4d6c6e..367b3307 100644
--- a/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
+++ b/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
@@ -23,6 +23,40 @@ class ButtonModel: ControlModel<Button> {
         buttonData.keyCode = code
         buttonData.keyName = name
         data = buttonData
-        button.setTitle(data.keyName, for: UIControl.State.normal)
+        updateTitle()
+    }
+
+    override func setModifierKey(code: Int) {
+        let name = KeyCodeNames.keyCodes[code] ?? "Btn"
+        setModifierKey(code: code, name: name)
+    }
+
+    override func setModifierKey(name: String) {
+        let code = KeyCodeNames.keyCodeByName[name] ?? KeyCodeNames.defaultCode
+        setModifierKey(code: code, name: name)
+    }
+
+    override func clearModifierKey() {
+        var buttonData = data
+        buttonData.modifierKeyCode = nil
+        buttonData.modifierKeyName = nil
+        data = buttonData
+        updateTitle()
+    }
+
+    private func setModifierKey(code: Int, name: String) {
+        var buttonData = data
+        buttonData.modifierKeyCode = code
+        buttonData.modifierKeyName = name
+        data = buttonData
+        updateTitle()
+    }
+
+    private func updateTitle() {
+        guard let modifierKeyName = data.modifierKeyName, !modifierKeyName.isEmpty else {
+            button.setTitle(data.keyName, for: UIControl.State.normal)
+            return
+        }
+        button.setTitle("\(modifierKeyName)+\n\(data.keyName)", for: UIControl.State.normal)
     }
 }
diff --git a/PlayTools/Editor/Models/Elements/Element.swift b/PlayTools/Editor/Models/Elements/Element.swift
index 472264fd..a2221a69 100644
--- a/PlayTools/Editor/Models/Elements/Element.swift
+++ b/PlayTools/Editor/Models/Elements/Element.swift
@@ -17,6 +17,8 @@ protocol BaseElement: Codable {
 struct Button: BaseElement {
     var keyCode: Int
     var keyName: String
+    var modifierKeyCode: Int?
+    var modifierKeyName: String?
     var transform: KeyModelTransform
 }
 

From 9d8644ac78109ea1642f4ab655fbd08457de9183 Mon Sep 17 00:00:00 2001
From: wqf <wukingfen@gmail.com>
Date: Mon, 11 May 2026 00:34:40 +0800
Subject: [PATCH 04/10] =?UTF-8?q?fix:=20ignore=20controller=20release=20ev?=
 =?UTF-8?q?ents=20in=20keymap=20editor=20/=20=E4=BF=AE=E5=A4=8D=E7=BC=96?=
 =?UTF-8?q?=E8=BE=91=E5=99=A8=E8=AF=AF=E6=8D=95=E8=8E=B7=E6=89=8B=E6=9F=84?=
 =?UTF-8?q?=E6=9D=BE=E5=BC=80=E4=BA=8B=E4=BB=B6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Controller/Instances/EditorControllerEventAdapter.swift    | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/PlayTools/Controls/Frontend/EventAdapter/Controller/Instances/EditorControllerEventAdapter.swift b/PlayTools/Controls/Frontend/EventAdapter/Controller/Instances/EditorControllerEventAdapter.swift
index 51edd172..66b011fb 100644
--- a/PlayTools/Controls/Frontend/EventAdapter/Controller/Instances/EditorControllerEventAdapter.swift
+++ b/PlayTools/Controls/Frontend/EventAdapter/Controller/Instances/EditorControllerEventAdapter.swift
@@ -14,6 +14,9 @@ public class EditorControllerEventAdapter: ControllerEventAdapter {
     public func handleValueChanged(_ profile: GCExtendedGamepad, _ element: GCControllerElement) {
         // This is the index of controller buttons, which is String, not Int
         var alias: String = element.aliases.first!
+        if let buttonElement = element as? GCControllerButtonInput, !buttonElement.isPressed {
+            return
+        }
         if alias == "Direction Pad" {
             guard let dpadElement = element as? GCControllerDirectionPad else {
                 Toast.showOver(msg: "cannot map direction pad: element type not recognizable")

From 114bf49fa1ffe668bfa0710ca0f0aa94dbc8fe92 Mon Sep 17 00:00:00 2001
From: wqf <wukingfen@gmail.com>
Date: Mon, 11 May 2026 01:27:54 +0800
Subject: [PATCH 05/10] =?UTF-8?q?fix:=20localize=20combo=20editor=20hints?=
 =?UTF-8?q?=20and=20shorten=20controller=20labels=20/=20=E6=9C=AC=E5=9C=B0?=
 =?UTF-8?q?=E5=8C=96=E7=BB=84=E5=90=88=E9=94=AE=E6=8F=90=E7=A4=BA=E5=B9=B6?=
 =?UTF-8?q?=E7=BC=A9=E7=9F=AD=E6=89=8B=E6=9F=84=E6=98=BE=E7=A4=BA?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Editor/Controllers/EditorController.swift |  53 +++++++++++++++---
 .../Elements/Instances/Button.swift           |  26 ++++++++-
 PlayTools/en.lproj/Playtools.strings          | Bin 3864 -> 5658 bytes
 PlayTools/zh-Hans.lproj/Playtools.strings     | Bin 1710 -> 3002 bytes
 4 files changed, 68 insertions(+), 11 deletions(-)

diff --git a/PlayTools/Editor/Controllers/EditorController.swift b/PlayTools/Editor/Controllers/EditorController.swift
index d80569a7..bbfe4996 100644
--- a/PlayTools/Editor/Controllers/EditorController.swift
+++ b/PlayTools/Editor/Controllers/EditorController.swift
@@ -110,30 +110,65 @@ class EditorController {
 
     public func captureModifierKey() {
         guard editorMode, focusedControl is ButtonModel else {
-            Toast.showHint(title: "Select a button first",
-                           text: ["Select a button mapping, then press ⌘M to set its modifier key."])
+            Toast.showHint(
+                title: NSLocalizedString("hint.keymappingEditor.selectButton.title",
+                                         tableName: "Playtools",
+                                         value: "Select a button first",
+                                         comment: ""),
+                text: [NSLocalizedString("hint.keymappingEditor.selectButton.captureModifier.content",
+                                         tableName: "Playtools",
+                                         value: "Select a button mapping, then press ⌘M to set its modifier key.",
+                                         comment: "")]
+            )
             return
         }
         keyCaptureMode = .modifier
-        Toast.showHint(title: "Press modifier key",
-                       text: ["The next keyboard, mouse, or controller button will become the modifier."])
+        Toast.showHint(
+            title: NSLocalizedString("hint.keymappingEditor.captureModifier.title",
+                                     tableName: "Playtools",
+                                     value: "Press modifier key",
+                                     comment: ""),
+            text: [NSLocalizedString("hint.keymappingEditor.captureModifier.content",
+                                     tableName: "Playtools",
+                                     value: "The next keyboard, mouse, or controller button will become the modifier.",
+                                     comment: "")]
+        )
     }
 
     public func clearModifierKey() {
         guard editorMode, focusedControl is ButtonModel else {
-            Toast.showHint(title: "Select a button first",
-                           text: ["Select a button mapping, then press ⌘⇧M to clear its modifier key."])
+            Toast.showHint(
+                title: NSLocalizedString("hint.keymappingEditor.selectButton.title",
+                                         tableName: "Playtools",
+                                         value: "Select a button first",
+                                         comment: ""),
+                text: [NSLocalizedString("hint.keymappingEditor.selectButton.clearModifier.content",
+                                         tableName: "Playtools",
+                                         value: "Select a button mapping, then press ⌘⇧M to clear its modifier key.",
+                                         comment: "")]
+            )
             return
         }
         focusedControl?.clearModifierKey()
         keyCaptureMode = .primary
-        Toast.showHint(title: "Modifier cleared")
+        Toast.showHint(title: NSLocalizedString("hint.keymappingEditor.modifierCleared.title",
+                                                tableName: "Playtools",
+                                                value: "Modifier cleared",
+                                                comment: ""))
     }
 
     private func finishModifierCapture() {
         keyCaptureMode = .primary
-        Toast.showHint(title: "Modifier set",
-                       text: ["Press another key to change the button's main binding."])
+        Toast.showHint(
+            title: NSLocalizedString("hint.keymappingEditor.modifierSet.title",
+                                     tableName: "Playtools",
+                                     value: "Modifier set",
+                                     comment: ""),
+            text: [NSLocalizedString("hint.keymappingEditor.modifierSet.content",
+                                     tableName: "Playtools",
+                                     value: "Press another key to change the button's main binding.",
+                                     comment: "")]
+        )
     }
 
     public func removeControl() {
diff --git a/PlayTools/Editor/Controllers/Elements/Instances/Button.swift b/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
index 367b3307..eed42e3a 100644
--- a/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
+++ b/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
@@ -8,6 +8,22 @@
 import Foundation
 
 class ButtonModel: ControlModel<Button> {
+    private static let shortKeyNames = [
+        "Button A": "A",
+        "Button B": "B",
+        "Button X": "X",
+        "Button Y": "Y",
+        "Button Menu": "Menu",
+        "Button Options": "Options",
+        "Direction Pad Up": "D-Up",
+        "Direction Pad Down": "D-Down",
+        "Direction Pad Left": "D-Left",
+        "Direction Pad Right": "D-Right",
+        "Left Shoulder": "LB",
+        "Left Trigger": "LT",
+        "Right Shoulder": "RB",
+        "Right Trigger": "RT"
+    ]
 
     override init(data: Button) {
         super.init(data: data)
@@ -53,10 +69,16 @@ class ButtonModel: ControlModel<Button> {
     }
 
     private func updateTitle() {
+        let keyName = Self.displayName(for: data.keyName)
         guard let modifierKeyName = data.modifierKeyName, !modifierKeyName.isEmpty else {
-            button.setTitle(data.keyName, for: UIControl.State.normal)
+            button.setTitle(keyName, for: UIControl.State.normal)
             return
         }
-        button.setTitle("\(modifierKeyName)+\n\(data.keyName)", for: UIControl.State.normal)
+        let modifierName = Self.displayName(for: modifierKeyName)
+        button.setTitle("\(modifierName)+\n\(keyName)", for: UIControl.State.normal)
+    }
+
+    private static func displayName(for keyName: String) -> String {
+        shortKeyNames[keyName] ?? keyName
     }
 }
diff --git a/PlayTools/en.lproj/Playtools.strings b/PlayTools/en.lproj/Playtools.strings
index 0836cf6ddfa073b861780e18eb9eac3ee8c4ee39..38ccd7b5e0539bbb16b8fa532eaa83cec4cf121e 100644
GIT binary patch
literal 5658
zcmd6r%Tg0T6oz}v6Sy4X!YaxN4`8`bV4;OrqB}Q}03i|v%ms)q>|3b+*C$Q)jFU_%
zCV`?d%yggbK9~R8`p@q@x9c+Z(Ov7=)$>Y!XRdH#ec!mDMs8i-ooeh<BON!@llh)T
z3%#9*rmeAEx94_T%U$^KvBpMvzjk--otubeq<1JegWc_nw#(hQ{~Bs-=HBSn(pXPF
z_Rlm2XG75s^vku+nZB<yI+?w9ll=pISJZu-btziT%e1nX@y<R`Mw=apmNVe0<z7pY
z9m(^!n(2s}b8!z}Q8%Cb_eioo7N28jcI>SYxk_yej&fmV?Ck<>HqU9q!;wGx#-pdV
zB;E{TWv-hs23B%;1bE71sfpeO9-BxXIIx*QIzexsEf*CUoIWYN)T8Z09OEl!V>zk%
zq8^DJ)c%l8`u+{SyqN7X&vVQAC)$`@#ya`Zuf-qE^@c9LNt4_3h4~1p^M@npEySm)
z<_gUbT?1l5L=9NlhQFZCX~m`o@>FnH7pGHCkCBy_N;bIi-i{o(w|4$uJBzBhb_GM^
zi#z=<YXnQ~YaLOa9mp~ht$>r50f-}Tm-#0MyV3l}f0<vE5n(%-oB>H4Q5Qas*-imp
zhD<UGz6`oTwu^jhK87{hqz-8x#B0@(nM-ZCUCvKr!CSAth?$hf%%v2Y$+XRy{4VTF
zg&s6Ym4Lre<Fw_KeRp5s|L|cfbMGrFH>KVGlVKn(@jCF{OR9%MAv~Sgo;+4@O{C#E
z$?CBZa_FXXyqKr9M+6apcyQojL#P`gzx$dCG?@@pjUo0O*KG#z&5}@w7d~G8TqsSM
z?&(TIXF_FwZT5xpk@CSn-&9qhkNBL>WIlgHs+g-D3teQNp8h~jIbH|;k0ldT=AL>e
z{MLG(G@1qv*-pf7LfJ(8l93l7>}x`^Ji1z{8PLSM_|X;)qBikKYKS!QeM#msAtq2{
z?%3z6;RAZiLz_=5*Q=I6`aXZq6Gs%D=q&1%e`7<r&Y{Aj#vudQ4sfyzA0UXzYd#O)
z$7ojPBX;(65j;gOy?=~@Z<A^cJ5hVVO<6;XP<ho=fM|ppgt69`PS(TAVhdL9DwgNB
zT;INuOxFES&2pzgheQSY?8T9v<Awu`rPXZ}4cRPjw%4wMfQ%}7wjuwo=TQUP*#wM&
z5j3=3Ei~D?4x6#ZoX^cFsBGe;d`}j!_hr^c(@WiZ#F#gB6g`Lmrw+WKH|sz7qNB6h
zJ#OB}oZM6pW2(K@ojlEMF}M$~`#?Ikw0lou)M{v~S~W%|`mXvIQAH>61iY|n6&qCf
zut>e^`R1|fJa?YWQw-8`Q~A)dVn4Hf=y1ClhoYz1XtgxYyqx(}xL*xDv2_Z;o;&U@
D3eDa>

delta 7
OcmbQGGed5J1U~=^1Oik5

diff --git a/PlayTools/zh-Hans.lproj/Playtools.strings b/PlayTools/zh-Hans.lproj/Playtools.strings
index b6109f214c8b6352babe614815c9bb9191654bd5..5eca5a30dfeeb8a0e840adb8c05d44ab844418d8 100644
GIT binary patch
delta 677
zcmZ3-yGwk-I=0DYSX8W%84?)^7)lsQ8HyNE8GIS?8B!QB8Pb3_6)2*_puk`Y#7YeN
zy7THCk~k-DCa;@vq>dv*Z|dX%77epxh8&>6M4(dKT3Pc_rlD!IV=@sh25JOpP6pcU
z1hl^d2=f{8Cf*n4`QGgj$T{I<63DX2K((eg)H3J+b>npZ<Xk3M1CT+wehhwEejvjX
z(pX}6{`UrQCMz&VDEk6^2J%;PbW0h;PfP|N>kRQ(ht<CztBmkj^;{8T87L&sEHjhD
z>Hdj#CAm10x&5HQZO4R1Eyw|SOM!}0(?MEV%Jin*C}T8Gn9rUemgJpu1SqOERmxu=
z$qH&5#HX^kXc6uVkIz(wl!^Bxxj;^aJHSK~U41Yx0!u*ZK;cM8-Q;{GX^rP~Z|gXd
k%L1?Y=}mnf{LbGp6%;WoW!8Qd>t;nW87MJWGjIVR0GsW$AOHXW

delta 7
OcmdlbzK(apIyL|dvjXt|


From 79ec88bce0098f06d059ac3281a13fccac33baad Mon Sep 17 00:00:00 2001
From: wqf <wukingfen@gmail.com>
Date: Mon, 11 May 2026 02:12:29 +0800
Subject: [PATCH 06/10] =?UTF-8?q?fix:=20keep=20controller=20face=20button?=
 =?UTF-8?q?=20labels=20explicit=20/=20=E4=BF=9D=E7=95=99=E6=89=8B=E6=9F=84?=
 =?UTF-8?q?=E9=9D=A2=E9=94=AE=E5=AE=8C=E6=95=B4=E6=98=BE=E7=A4=BA?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 PlayTools/Editor/Controllers/Elements/Instances/Button.swift | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/PlayTools/Editor/Controllers/Elements/Instances/Button.swift b/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
index eed42e3a..4e8217dc 100644
--- a/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
+++ b/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
@@ -9,10 +9,6 @@ import Foundation
 
 class ButtonModel: ControlModel<Button> {
     private static let shortKeyNames = [
-        "Button A": "A",
-        "Button B": "B",
-        "Button X": "X",
-        "Button Y": "Y",
         "Button Menu": "Menu",
         "Button Options": "Options",
         "Direction Pad Up": "D-Up",

From 6141528cf11276709b78eed43a2ca5bd8fc1bfc9 Mon Sep 17 00:00:00 2001
From: wqf <wukingfen@gmail.com>
Date: Tue, 12 May 2026 22:26:43 +0800
Subject: [PATCH 07/10] =?UTF-8?q?feat:=20add=20triggered=20swipe=20mapping?=
 =?UTF-8?q?s=20/=20=E6=96=B0=E5=A2=9E=E6=8C=89=E9=94=AE=E8=A7=A6=E5=8F=91?=
 =?UTF-8?q?=E6=BB=91=E5=8A=A8=E6=98=A0=E5=B0=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 PlayTools/Controls/ActionDispatcher.swift     |   4 +
 .../Controls/Backend/Action/PlayAction.swift  |  80 ++++++++++++++-
 PlayTools/Controls/MenuController.swift       |  11 +++
 .../Editor/Controllers/EditorController.swift |  46 ++++++++-
 .../Elements/ElementController.swift          |   3 +
 .../Elements/Instances/Button.swift           |  92 +++++++++++++++++-
 .../Editor/Models/Elements/Element.swift      |   3 +
 PlayTools/Editor/Views/EditorCircleMenu.swift |   7 +-
 PlayTools/Keymap/Keymapping.swift             |   1 +
 PlayTools/en.lproj/Playtools.strings          | Bin 5658 -> 6254 bytes
 PlayTools/zh-Hans.lproj/Playtools.strings     | Bin 3002 -> 3414 bytes
 11 files changed, 238 insertions(+), 9 deletions(-)

diff --git a/PlayTools/Controls/ActionDispatcher.swift b/PlayTools/Controls/ActionDispatcher.swift
index dae3e11d..159656c2 100644
--- a/PlayTools/Controls/ActionDispatcher.swift
+++ b/PlayTools/Controls/ActionDispatcher.swift
@@ -81,6 +81,10 @@ public class ActionDispatcher {
             actions.append(CameraAction(data: mouse))
         }
 
+        for swipe in keymap.currentKeymap.swipeModels {
+            actions.append(TriggeredSwipeAction(data: swipe))
+        }
+
         for joystick in keymap.currentKeymap.joystickModel {
             // Left Thumbstick, Right Thumbstick, Mouse
             if JoystickModel.isAnalog(joystick) {
diff --git a/PlayTools/Controls/Backend/Action/PlayAction.swift b/PlayTools/Controls/Backend/Action/PlayAction.swift
index 03385467..f20170a3 100644
--- a/PlayTools/Controls/Backend/Action/PlayAction.swift
+++ b/PlayTools/Controls/Backend/Action/PlayAction.swift
@@ -85,7 +85,7 @@ class ButtonAction: Action {
         }
     }
 
-    private static func dispatchNames(code: Int?, name: String?) -> [String] {
+    fileprivate static func dispatchNames(code: Int?, name: String?) -> [String] {
         guard let name = name, !name.isEmpty else {
             return []
         }
@@ -98,6 +98,84 @@ class ButtonAction: Action {
     }
 }
 
+class TriggeredSwipeAction: Action {
+    private let keyName: String
+    private let modifierKeys: [String]
+    private let startPoint: CGPoint
+    private let endPoint: CGPoint
+    private var keyIsPressed = false
+    private var id: Int?
+
+    init(data: Swipe) {
+        self.keyName = data.keyName
+        self.modifierKeys = ButtonAction.dispatchNames(code: data.modifierKeyCode,
+                                                       name: data.modifierKeyName)
+        self.startPoint = CGPoint(
+            x: data.transform.xCoord.absoluteX,
+            y: data.transform.yCoord.absoluteY)
+        let length = data.transform.size.absoluteSize
+        self.endPoint = CGPoint(
+            x: startPoint.x + cos(data.angle) * length,
+            y: startPoint.y + sin(data.angle) * length)
+
+        for key in ButtonAction.dispatchNames(code: data.keyCode, name: data.keyName) {
+            ActionDispatcher.register(key: key, modifierKeys: modifierKeys, handler: self.update)
+        }
+        for key in modifierKeys {
+            ActionDispatcher.register(key: key, handler: self.updateModifier)
+        }
+    }
+
+    func update(pressed: Bool) {
+        if pressed {
+            guard !keyIsPressed else {
+                return
+            }
+            keyIsPressed = true
+            performSwipe()
+        } else {
+            keyIsPressed = false
+        }
+    }
+
+    private func updateModifier(pressed: Bool) {
+        if !pressed {
+            keyIsPressed = false
+        }
+    }
+
+    private func performSwipe() {
+        guard id == nil else {
+            return
+        }
+        let stepCount = 6
+        Toucher.touchcam(point: startPoint, phase: UITouch.Phase.began, tid: &id,
+                         actionName: "Swipe", keyName: keyName)
+        for step in 1...stepCount {
+            let progress = CGFloat(step) / CGFloat(stepCount)
+            let point = CGPoint(
+                x: startPoint.x + (endPoint.x - startPoint.x) * progress,
+                y: startPoint.y + (endPoint.y - startPoint.y) * progress)
+            PlayInput.touchQueue.asyncAfter(deadline: .now() + 0.012 * Double(step),
+                                            qos: .userInteractive) {
+                Toucher.touchcam(point: point, phase: UITouch.Phase.moved, tid: &self.id,
+                                 actionName: "Swipe", keyName: self.keyName)
+            }
+        }
+        PlayInput.touchQueue.asyncAfter(deadline: .now() + 0.012 * Double(stepCount + 1),
+                                        qos: .userInteractive) {
+            Toucher.touchcam(point: self.endPoint, phase: UITouch.Phase.ended, tid: &self.id,
+                             actionName: "Swipe", keyName: self.keyName)
+        }
+    }
+
+    func invalidate() {
+        keyIsPressed = false
+        Toucher.touchcam(point: endPoint, phase: UITouch.Phase.ended, tid: &id,
+                         actionName: "Swipe", keyName: keyName)
+    }
+}
+
 class DraggableButtonAction: ButtonAction {
     var releasePoint: CGPoint
 
diff --git a/PlayTools/Controls/MenuController.swift b/PlayTools/Controls/MenuController.swift
index c60b7c8f..d60c4315 100644
--- a/PlayTools/Controls/MenuController.swift
+++ b/PlayTools/Controls/MenuController.swift
@@ -55,6 +55,11 @@ extension UIApplication {
         EditorController.shared.clearModifierKey()
     }
 
+    @objc
+    func cycleSwipeDirection(_ sender: AnyObject) {
+        EditorController.shared.cycleSwipeDirection()
+    }
+
     // put a mark in the toucher log, so as to align with tester description
     @objc
     func markToucherLog(_ sender: AnyObject) {
@@ -155,6 +160,8 @@ var keymapping = [
                       value: "Set selected button modifier", comment: ""),
     NSLocalizedString("menu.keymapping.clearModifier", tableName: "Playtools",
                       value: "Clear selected button modifier", comment: ""),
+    NSLocalizedString("menu.keymapping.cycleSwipeDirection", tableName: "Playtools",
+                      value: "Switch selected swipe direction", comment: ""),
     NSLocalizedString("menu.keymapping.toggleDebug", tableName: "Playtools",
                       value: "Toggle Debug Overlay", comment: ""),
     NSLocalizedString("menu.keymapping.hide.pointer", tableName: "Playtools",
@@ -171,6 +178,7 @@ var iconsSelctor = [
     UIImage(systemName: "square.resize.down"),
     UIImage(systemName: "command"),
     UIImage(systemName: "command.circle"),
+    UIImage(systemName: "arrow.triangle.2.circlepath"),
     UIImage(systemName: "wrench.and.screwdriver"),
     UIImage(systemName: "pointer.arrow.slash"),
     UIImage(systemName: "arrow.down.square"),
@@ -182,6 +190,7 @@ var keymappingSelectors = [#selector(UIApplication.switchEditorMode(_:)),
                            #selector(UIApplication.downscaleElement(_:)),
                            #selector(UIApplication.captureElementModifierKey(_:)),
                            #selector(UIApplication.clearElementModifierKey(_:)),
+                           #selector(UIApplication.cycleSwipeDirection(_:)),
                            #selector(UIApplication.toggleDebugOverlay(_:)),
                            #selector(UIApplication.hideCursor(_:)),
                            #selector(UIApplication.previousKeymap(_:)),
@@ -253,6 +262,7 @@ class MenuController {
             UIKeyCommand.inputDownArrow,    // Decrease keymap element size
             "M",                            // Set button modifier
             "M",                            // Clear button modifier
+            "R",                            // Switch swipe direction
             "D",                            // Toggle debug overlay
             ".",                            // Hide cursor until move
             "[",                            // Previous keymap
@@ -268,6 +278,7 @@ class MenuController {
             .command,
             .command,
             .command,
+            .command,
             .command
         ]
         let arrowKeyChildrenCommands = zip(zip(zip(keyCommands, keymapping), iconsSelctor), keyModifiers)
diff --git a/PlayTools/Editor/Controllers/EditorController.swift b/PlayTools/Editor/Controllers/EditorController.swift
index bbfe4996..9f995253 100644
--- a/PlayTools/Editor/Controllers/EditorController.swift
+++ b/PlayTools/Editor/Controllers/EditorController.swift
@@ -109,7 +109,7 @@ class EditorController {
     }
 
     public func captureModifierKey() {
-        guard editorMode, focusedControl is ButtonModel else {
+        guard editorMode, focusedControl is ButtonModel || focusedControl is SwipeModel else {
             Toast.showHint(
                 title: NSLocalizedString("hint.keymappingEditor.selectButton.title",
                                          tableName: "Playtools",
@@ -117,7 +117,8 @@ class EditorController {
                                          comment: ""),
                 text: [NSLocalizedString("hint.keymappingEditor.selectButton.captureModifier.content",
                                          tableName: "Playtools",
-                                         value: "Select a button mapping, then press ⌘M to set its modifier key.",
+                                         value: "Select a button or swipe mapping, then press ⌘M "
+                                            + "to set its modifier key.",
                                          comment: "")]
             )
             return
@@ -136,7 +137,7 @@ class EditorController {
     }
 
     public func clearModifierKey() {
-        guard editorMode, focusedControl is ButtonModel else {
+        guard editorMode, focusedControl is ButtonModel || focusedControl is SwipeModel else {
             Toast.showHint(
                 title: NSLocalizedString("hint.keymappingEditor.selectButton.title",
                                          tableName: "Playtools",
@@ -144,7 +145,8 @@ class EditorController {
                                          comment: ""),
                 text: [NSLocalizedString("hint.keymappingEditor.selectButton.clearModifier.content",
                                          tableName: "Playtools",
-                                         value: "Select a button mapping, then press ⌘⇧M to clear its modifier key.",
+                                         value: "Select a button or swipe mapping, then press ⌘⇧M "
+                                            + "to clear its modifier key.",
                                          comment: "")]
             )
             return
@@ -177,6 +179,23 @@ class EditorController {
         focusedControl?.remove()
     }
 
+    public func cycleSwipeDirection() {
+        guard editorMode, focusedControl is SwipeModel else {
+            Toast.showHint(
+                title: NSLocalizedString("hint.keymappingEditor.selectSwipe.title",
+                                         tableName: "Playtools",
+                                         value: "Select a swipe first",
+                                         comment: ""),
+                text: [NSLocalizedString("hint.keymappingEditor.selectSwipe.cycleDirection.content",
+                                         tableName: "Playtools",
+                                         value: "Select a swipe mapping, then press ⌘R to change its direction.",
+                                         comment: "")]
+            )
+            return
+        }
+        focusedControl?.cycleDirection()
+    }
+
     func showButtons() {
         for button in keymap.currentKeymap.draggableButtonModels {
             let ctrl = DraggableButtonModel(data: button)
@@ -191,6 +210,10 @@ class EditorController {
                 MouseAreaModel(data: mouse)
             addControlToView(control: ctrl)
         }
+        for swipe in keymap.currentKeymap.swipeModels {
+            let ctrl = SwipeModel(data: swipe)
+            addControlToView(control: ctrl)
+        }
         for button in keymap.currentKeymap.buttonModels {
             let ctrl = ButtonModel(data: button)
             addControlToView(control: ctrl)
@@ -208,6 +231,8 @@ class EditorController {
                 keymapData.draggableButtonModels.append(model.save())
             case let model as MouseAreaModel:
                 keymapData.mouseAreaModel.append(model.save())
+            case let model as SwipeModel:
+                keymapData.swipeModels.append(model.save())
             case let model as ButtonModel:
                 keymapData.buttonModels.append(model.save())
             default:
@@ -286,6 +311,19 @@ class EditorController {
         }
     }
 
+    public func addSwipe(_ center: CGPoint) {
+        if editorMode {
+            addControlToView(control: SwipeModel(data: Swipe(
+                keyCode: -1,
+                keyName: KeyCodeNames.leftMouseButton,
+                transform: KeyModelTransform(
+                    size: 12, xCoord: center.x.relativeX, yCoord: center.y.relativeY
+                ),
+                angle: CGFloat.pi * 3 / 2
+            )))
+        }
+    }
+
     public func addDraggableButton(_ center: CGPoint, _ keyCode: Int) {
         if editorMode {
             addControlToView(control: DraggableButtonModel(data: Button(
diff --git a/PlayTools/Editor/Controllers/Elements/ElementController.swift b/PlayTools/Editor/Controllers/Elements/ElementController.swift
index ba4e20f5..31b051c0 100644
--- a/PlayTools/Editor/Controllers/Elements/ElementController.swift
+++ b/PlayTools/Editor/Controllers/Elements/ElementController.swift
@@ -16,6 +16,7 @@ protocol ControlElement: AnyObject {
     func setModifierKey(code: Int)
     func setModifierKey(name: String)
     func clearModifierKey()
+    func cycleDirection()
     func resize(down: Bool)
     func remove()
 }
@@ -80,4 +81,6 @@ class ControlModel<ElementType: BaseElement>: ControlElement {
     func setModifierKey(name: String) {}
 
     func clearModifierKey() {}
+
+    func cycleDirection() {}
 }
diff --git a/PlayTools/Editor/Controllers/Elements/Instances/Button.swift b/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
index 4e8217dc..551f15b4 100644
--- a/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
+++ b/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
@@ -8,7 +8,7 @@
 import Foundation
 
 class ButtonModel: ControlModel<Button> {
-    private static let shortKeyNames = [
+    fileprivate static let shortKeyNames = [
         "Button Menu": "Menu",
         "Button Options": "Options",
         "Direction Pad Up": "D-Up",
@@ -74,7 +74,95 @@ class ButtonModel: ControlModel<Button> {
         button.setTitle("\(modifierName)+\n\(keyName)", for: UIControl.State.normal)
     }
 
-    private static func displayName(for keyName: String) -> String {
+    fileprivate static func displayName(for keyName: String) -> String {
         shortKeyNames[keyName] ?? keyName
     }
 }
+
+class SwipeModel: ControlModel<Swipe> {
+    private static let directions: [(name: String, angle: CGFloat)] = [
+        ("Right", 0),
+        ("Down", CGFloat.pi / 2),
+        ("Left", CGFloat.pi),
+        ("Up", CGFloat.pi * 3 / 2)
+    ]
+
+    override init(data: Swipe) {
+        super.init(data: data)
+        button.layer.cornerRadius = 0.25 * button.bounds.size.width
+        updateTitle()
+    }
+
+    func save() -> Swipe {
+        data
+    }
+
+    override func setKey(code: Int, name: String) {
+        var swipeData = data
+        swipeData.keyCode = code
+        swipeData.keyName = name
+        data = swipeData
+        updateTitle()
+    }
+
+    override func setModifierKey(code: Int) {
+        let name = KeyCodeNames.keyCodes[code] ?? "Btn"
+        setModifierKey(code: code, name: name)
+    }
+
+    override func setModifierKey(name: String) {
+        let code = KeyCodeNames.keyCodeByName[name] ?? KeyCodeNames.defaultCode
+        setModifierKey(code: code, name: name)
+    }
+
+    override func clearModifierKey() {
+        var swipeData = data
+        swipeData.modifierKeyCode = nil
+        swipeData.modifierKeyName = nil
+        data = swipeData
+        updateTitle()
+    }
+
+    override func cycleDirection() {
+        var swipeData = data
+        let currentIndex = Self.nearestDirectionIndex(for: swipeData.angle)
+        let nextIndex = (currentIndex + 1) % Self.directions.count
+        swipeData.angle = Self.directions[nextIndex].angle
+        data = swipeData
+        updateTitle()
+    }
+
+    private func setModifierKey(code: Int, name: String) {
+        var swipeData = data
+        swipeData.modifierKeyCode = code
+        swipeData.modifierKeyName = name
+        data = swipeData
+        updateTitle()
+    }
+
+    private func updateTitle() {
+        let keyName = ButtonModel.displayName(for: data.keyName)
+        let direction = Self.directions[Self.nearestDirectionIndex(for: data.angle)].name
+        let title = "\(direction)\n\(keyName)"
+        guard let modifierKeyName = data.modifierKeyName, !modifierKeyName.isEmpty else {
+            button.setTitle(title, for: UIControl.State.normal)
+            return
+        }
+        let modifierName = ButtonModel.displayName(for: modifierKeyName)
+        button.setTitle("\(modifierName)+\n\(keyName) \(direction)", for: UIControl.State.normal)
+    }
+
+    private static func nearestDirectionIndex(for angle: CGFloat) -> Int {
+        let twoPi = CGFloat.pi * 2
+        let normalized = angle.truncatingRemainder(dividingBy: twoPi) + (angle < 0 ? twoPi : 0)
+        return directions.enumerated().min { lhs, rhs in
+            angularDistance(lhs.element.angle, normalized) < angularDistance(rhs.element.angle, normalized)
+        }?.offset ?? 0
+    }
+
+    private static func angularDistance(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat {
+        let twoPi = CGFloat.pi * 2
+        let distance = abs(lhs - rhs).truncatingRemainder(dividingBy: twoPi)
+        return min(distance, twoPi - distance)
+    }
+}
diff --git a/PlayTools/Editor/Models/Elements/Element.swift b/PlayTools/Editor/Models/Elements/Element.swift
index a2221a69..64ed3e62 100644
--- a/PlayTools/Editor/Models/Elements/Element.swift
+++ b/PlayTools/Editor/Models/Elements/Element.swift
@@ -57,7 +57,10 @@ struct MouseArea: BaseElement {
 // and move to a user-defined pos (polar coordinate system defined by size and angle)
 // and end.
 struct Swipe: BaseElement {
+    var keyCode: Int
     var keyName: String
+    var modifierKeyCode: Int?
+    var modifierKeyName: String?
     var transform: KeyModelTransform
     // [0, 2 * PI)
     var angle: CGFloat
diff --git a/PlayTools/Editor/Views/EditorCircleMenu.swift b/PlayTools/Editor/Views/EditorCircleMenu.swift
index 80d5719b..0f404157 100644
--- a/PlayTools/Editor/Views/EditorCircleMenu.swift
+++ b/PlayTools/Editor/Views/EditorCircleMenu.swift
@@ -20,7 +20,7 @@ class EditorCircleMenu: CircleMenuDelegate {
             frame: CGRect(x: 0, y: 0, width: 50, height: 50),
             normalIcon: "xmark.circle.fill",
             selectedIcon: "xmark.circle.fill",
-            buttonsCount: 3,
+            buttonsCount: 4,
             duration: 0.25,
             distance: 80)
         menu?.delegate = self
@@ -56,6 +56,8 @@ class EditorCircleMenu: CircleMenuDelegate {
             EditorController.shared.addJoystick(globalPoint!)
         case 2:
             EditorController.shared.addMouseArea(globalPoint!)
+        case 3:
+            EditorController.shared.addSwipe(globalPoint!)
         default:
             Toast.showHint(title: "item \(atIndex) is not recognizable")
 //            EditorController.shared.addMouseJoystick(globalPoint!)
@@ -77,6 +79,7 @@ class EditorCircleMenu: CircleMenuDelegate {
 //          "arrow.up.and.down.and.arrow.left.and.right",
 //          "rb.rectangle.roundedbottom.fill",
 //          "lb.rectangle.roundedbottom",
-          "computermouse"
+          "computermouse",
+          "hand.draw"
       ]
 }
diff --git a/PlayTools/Keymap/Keymapping.swift b/PlayTools/Keymap/Keymapping.swift
index 862a16a1..de51bb29 100644
--- a/PlayTools/Keymap/Keymapping.swift
+++ b/PlayTools/Keymap/Keymapping.swift
@@ -160,6 +160,7 @@ struct KeymappingData: Codable {
     var draggableButtonModels: [Button] = []
     var joystickModel: [Joystick] = []
     var mouseAreaModel: [MouseArea] = []
+    var swipeModels: [Swipe] = []
     var bundleIdentifier: String
     var version = "2.0.0"
 }
diff --git a/PlayTools/en.lproj/Playtools.strings b/PlayTools/en.lproj/Playtools.strings
index 38ccd7b5e0539bbb16b8fa532eaa83cec4cf121e..04496fa10a9ebde847cff5dbfa5ab6137447282b 100644
GIT binary patch
delta 377
zcmbQG^Uh#H9slGIW`W5f0uqy#@Fzjplce(*iWn3aiW$loG8qaOQi1F=Agc%{QZm_5
z#B}ltL77Q{Vf<*yHU|qbGhzw~9c7-ph+oCBk|CKP2WVI@+*lW|p{YRe5+Ey|A&)@`
zXq7DxD?wG20Oc|!f8-aHMRrUIx<0U@A_RCi;bu=ZWD=j;CLkn=tPj-_K=tZy^$dDI
zn_w=)aMxsML0wL`Nt1&Gb*+Mct}Fq%SpnoihD4y-)4>6i2^1{`iek7CXoC`iH3Js|
E08F$}!vFvP

delta 55
zcmaE7FiU4c9sguGcAm*S{54QoYO;Yq)#L<mugNk(0+YoA!zND<(we+N@Y?1HLWh`{
GxEKHjxDmww

diff --git a/PlayTools/zh-Hans.lproj/Playtools.strings b/PlayTools/zh-Hans.lproj/Playtools.strings
index 5eca5a30dfeeb8a0e840adb8c05d44ab844418d8..b8f74956b02ccab29e6ac6316b60ab21a3c29c47 100644
GIT binary patch
delta 275
zcmdlbeoblv6FZke8cWQPI*t&%sgny>G$xy{>#%@?Ca>ePnmmu)icKu(V&00N$$5-o
zlNWH<P1fLWfeGbsY=Sa3%W=+Pnq0=B<dDoz$&k#D!;s1l%uvpd$xr}fxd7=RAf3!m
z0%YYg<S{5QC@|Opu@VD&P*So(66XYv9XnG6LnileIB>$XPP{KZ`3yS;3z7@;)ZwxW
zdO#y#)?rvOIiE>-vH&NS7DzM5M?C*~138lw7$lT~fL4PnZjNp#16j&spu}L!z{LOn
DsZ~o%

delta 67
zcmca6wM%>h6FV1Y^13NU>NrC5rcN$k(U@$)uEPQnnrz2yHF+Mp)no%6hspOi1SVf$
WlbP(tp)t9JW7B36&RI-MTnqpN0u_n?


From 04496924537085e1ec0ec38bd3e6cc1082482e9a Mon Sep 17 00:00:00 2001
From: wqf <wukingfen@gmail.com>
Date: Wed, 13 May 2026 01:38:01 +0800
Subject: [PATCH 08/10] =?UTF-8?q?feat:=20improve=20swipe=20feel=20and=20pr?=
 =?UTF-8?q?eserve=20legacy=20keymaps=20/=20=E4=BC=98=E5=8C=96=E6=BB=91?=
 =?UTF-8?q?=E5=8A=A8=E6=89=8B=E6=84=9F=E5=B9=B6=E4=BF=9D=E6=8C=81=E6=97=A7?=
 =?UTF-8?q?=E9=94=AE=E4=BD=8D=E5=85=BC=E5=AE=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../Controls/Backend/Action/PlayAction.swift  | 22 ++++-
 .../Elements/Instances/Button.swift           | 11 ++-
 .../Editor/Views/Elements/ElementView.swift   | 91 +++++++++++++++++++
 PlayTools/Keymap/Keymapping.swift             | 31 ++++++-
 4 files changed, 148 insertions(+), 7 deletions(-)

diff --git a/PlayTools/Controls/Backend/Action/PlayAction.swift b/PlayTools/Controls/Backend/Action/PlayAction.swift
index f20170a3..32dee765 100644
--- a/PlayTools/Controls/Backend/Action/PlayAction.swift
+++ b/PlayTools/Controls/Backend/Action/PlayAction.swift
@@ -148,27 +148,39 @@ class TriggeredSwipeAction: Action {
         guard id == nil else {
             return
         }
-        let stepCount = 6
+        let length = hypot(endPoint.x - startPoint.x, endPoint.y - startPoint.y)
+        let stepCount = 12
+        let totalDuration = Self.swipeDuration(for: length)
         Toucher.touchcam(point: startPoint, phase: UITouch.Phase.began, tid: &id,
                          actionName: "Swipe", keyName: keyName)
         for step in 1...stepCount {
             let progress = CGFloat(step) / CGFloat(stepCount)
+            let easedProgress = Self.easeInOut(progress)
             let point = CGPoint(
-                x: startPoint.x + (endPoint.x - startPoint.x) * progress,
-                y: startPoint.y + (endPoint.y - startPoint.y) * progress)
-            PlayInput.touchQueue.asyncAfter(deadline: .now() + 0.012 * Double(step),
+                x: startPoint.x + (endPoint.x - startPoint.x) * easedProgress,
+                y: startPoint.y + (endPoint.y - startPoint.y) * easedProgress)
+            PlayInput.touchQueue.asyncAfter(deadline: .now() + totalDuration * Double(progress),
                                             qos: .userInteractive) {
                 Toucher.touchcam(point: point, phase: UITouch.Phase.moved, tid: &self.id,
                                  actionName: "Swipe", keyName: self.keyName)
             }
         }
-        PlayInput.touchQueue.asyncAfter(deadline: .now() + 0.012 * Double(stepCount + 1),
+        PlayInput.touchQueue.asyncAfter(deadline: .now() + totalDuration,
                                         qos: .userInteractive) {
             Toucher.touchcam(point: self.endPoint, phase: UITouch.Phase.ended, tid: &self.id,
                              actionName: "Swipe", keyName: self.keyName)
         }
     }
 
+    private static func swipeDuration(for length: CGFloat) -> Double {
+        let normalized = min(max(Double(length) / 420.0, 0.0), 1.0)
+        return 0.18 + normalized * 0.16
+    }
+
+    private static func easeInOut(_ progress: CGFloat) -> CGFloat {
+        progress * progress * (3 - 2 * progress)
+    }
+
     func invalidate() {
         keyIsPressed = false
         Toucher.touchcam(point: endPoint, phase: UITouch.Phase.ended, tid: &id,
diff --git a/PlayTools/Editor/Controllers/Elements/Instances/Button.swift b/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
index 551f15b4..bff77e49 100644
--- a/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
+++ b/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
@@ -89,7 +89,16 @@ class SwipeModel: ControlModel<Swipe> {
 
     override init(data: Swipe) {
         super.init(data: data)
-        button.layer.cornerRadius = 0.25 * button.bounds.size.width
+        button.removeFromSuperview()
+        button = SwipeElement(
+            frame: CGRect(
+                x: data.transform.xCoord.absoluteX - data.transform.size.absoluteSize / 2,
+                y: data.transform.yCoord.absoluteY - data.transform.size.absoluteSize / 2,
+                width: data.transform.size.absoluteSize,
+                height: data.transform.size.absoluteSize
+            )
+        )
+        button.model = self
         updateTitle()
     }
 
diff --git a/PlayTools/Editor/Views/Elements/ElementView.swift b/PlayTools/Editor/Views/Elements/ElementView.swift
index 532852d2..ddf07838 100644
--- a/PlayTools/Editor/Views/Elements/ElementView.swift
+++ b/PlayTools/Editor/Views/Elements/ElementView.swift
@@ -62,6 +62,97 @@ class Element: UIButton {
     }
 }
 
+class SwipeElement: Element {
+    private let lineLayer = CAShapeLayer()
+    private let startLayer = CAShapeLayer()
+    private let endLayer = CAShapeLayer()
+    private let arrowLayer = CAShapeLayer()
+
+    override func commonInit() {
+        super.commonInit()
+        backgroundColor = .clear
+        clipsToBounds = false
+        layer.masksToBounds = false
+        titleLabel?.backgroundColor = UIColor.black.withAlphaComponent(0.65)
+        titleLabel?.layer.cornerRadius = 6
+        titleLabel?.clipsToBounds = true
+        titleLabel?.font = UIFont.systemFont(ofSize: 13, weight: .semibold)
+
+        lineLayer.fillColor = UIColor.clear.cgColor
+        lineLayer.lineCap = .round
+        lineLayer.lineWidth = 4
+        startLayer.fillColor = UIColor.systemTeal.cgColor
+        endLayer.fillColor = UIColor.systemPink.cgColor
+        arrowLayer.fillColor = UIColor.systemPink.cgColor
+
+        layer.insertSublayer(lineLayer, at: 0)
+        layer.insertSublayer(startLayer, at: 0)
+        layer.insertSublayer(endLayer, at: 0)
+        layer.insertSublayer(arrowLayer, at: 0)
+        update()
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        update()
+    }
+
+    override func update() {
+        layer.cornerRadius = 0
+        updateSwipePath(isFocused: layer.borderWidth > 0)
+    }
+
+    override func focus(_ focus: Bool) {
+        layer.borderWidth = 0
+        updateSwipePath(isFocused: focus)
+    }
+
+    private func updateSwipePath(isFocused: Bool) {
+        guard let swipeModel = model as? SwipeModel else {
+            return
+        }
+
+        let start = CGPoint(x: bounds.midX, y: bounds.midY)
+        let length = max(bounds.width, 32)
+        let angle = swipeModel.data.angle
+        let end = CGPoint(
+            x: start.x + cos(angle) * length,
+            y: start.y + sin(angle) * length
+        )
+
+        let path = UIBezierPath()
+        path.move(to: start)
+        path.addLine(to: end)
+        lineLayer.path = path.cgPath
+        lineLayer.strokeColor = (isFocused ? UIColor.systemYellow : UIColor.systemPink).cgColor
+        lineLayer.lineWidth = isFocused ? 6 : 4
+
+        startLayer.path = UIBezierPath(
+            ovalIn: CGRect(x: start.x - 6, y: start.y - 6, width: 12, height: 12)
+        ).cgPath
+        endLayer.path = UIBezierPath(
+            ovalIn: CGRect(x: end.x - 8, y: end.y - 8, width: 16, height: 16)
+        ).cgPath
+
+        let arrowLength: CGFloat = 14
+        let arrowSpread: CGFloat = .pi / 7
+        let left = CGPoint(
+            x: end.x - cos(angle - arrowSpread) * arrowLength,
+            y: end.y - sin(angle - arrowSpread) * arrowLength
+        )
+        let right = CGPoint(
+            x: end.x - cos(angle + arrowSpread) * arrowLength,
+            y: end.y - sin(angle + arrowSpread) * arrowLength
+        )
+        let arrowPath = UIBezierPath()
+        arrowPath.move(to: end)
+        arrowPath.addLine(to: left)
+        arrowPath.addLine(to: right)
+        arrowPath.close()
+        arrowLayer.path = arrowPath.cgPath
+    }
+}
+
 extension UIView {
     func setX(xCoord: CGFloat) {
         self.center = CGPoint(x: xCoord, y: self.center.y)
diff --git a/PlayTools/Keymap/Keymapping.swift b/PlayTools/Keymap/Keymapping.swift
index de51bb29..a863c926 100644
--- a/PlayTools/Keymap/Keymapping.swift
+++ b/PlayTools/Keymap/Keymapping.swift
@@ -110,7 +110,7 @@ class Keymapping {
             print("[PlayTools] Keymapping decode failed.\n%@")
         }
 
-        return resetKeymap(path: path)
+        return KeymappingData(bundleIdentifier: bundleIdentifier)
     }
 
     private func setKeymap(path: URL, map: KeymappingData) {
@@ -163,6 +163,35 @@ struct KeymappingData: Codable {
     var swipeModels: [Swipe] = []
     var bundleIdentifier: String
     var version = "2.0.0"
+
+    init(buttonModels: [Button] = [],
+         draggableButtonModels: [Button] = [],
+         joystickModel: [Joystick] = [],
+         mouseAreaModel: [MouseArea] = [],
+         swipeModels: [Swipe] = [],
+         bundleIdentifier: String,
+         version: String = "2.0.0") {
+        self.buttonModels = buttonModels
+        self.draggableButtonModels = draggableButtonModels
+        self.joystickModel = joystickModel
+        self.mouseAreaModel = mouseAreaModel
+        self.swipeModels = swipeModels
+        self.bundleIdentifier = bundleIdentifier
+        self.version = version
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        self.init(
+            buttonModels: try container.decodeIfPresent([Button].self, forKey: .buttonModels) ?? [],
+            draggableButtonModels: try container.decodeIfPresent([Button].self, forKey: .draggableButtonModels) ?? [],
+            joystickModel: try container.decodeIfPresent([Joystick].self, forKey: .joystickModel) ?? [],
+            mouseAreaModel: try container.decodeIfPresent([MouseArea].self, forKey: .mouseAreaModel) ?? [],
+            swipeModels: try container.decodeIfPresent([Swipe].self, forKey: .swipeModels) ?? [],
+            bundleIdentifier: try container.decode(String.self, forKey: .bundleIdentifier),
+            version: try container.decodeIfPresent(String.self, forKey: .version) ?? "2.0.0"
+        )
+    }
 }
 
 struct KeymapConfig: Codable {

From 1423632116bb0ecc21f91b4f5ae892f0ce98b6e2 Mon Sep 17 00:00:00 2001
From: wqf <wukingfen@gmail.com>
Date: Sat, 16 May 2026 17:19:42 +0800
Subject: [PATCH 09/10] =?UTF-8?q?feat:=20add=20keymap=20HUD=20and=20radial?=
 =?UTF-8?q?=20controls=20/=20=E6=96=B0=E5=A2=9E=E6=98=A0=E5=B0=84=E6=8F=90?=
 =?UTF-8?q?=E7=A4=BA=E5=B1=82=E5=92=8C=E8=BD=AE=E7=9B=98=E6=8E=A7=E5=88=B6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add a read-only keymap HUD with per-keymap hudOpacity support and localized menu toggle.

- Support radial selector mappings, long-press triggers, triggered swipes, and shoulder-button keymap switching.

- Refresh the HUD after switching keymaps and keep Toast/keymap switching UI work on the main thread.

- Improve controller/key display names and localize new keymapping menu items and hints.

- 新增只读映射提示层，支持每个映射配置通过 hudOpacity 控制透明度，并补充菜单本地化。

- 支持轮盘映射、长按触发、按键触发滑动，以及肩键切换映射配置。

- 切换映射后自动刷新 HUD，并将 Toast/切换 UI 操作切回主线程，减少黑框和卡顿。

- 优化手柄按键显示名称，并补齐新增按键映射菜单和提示文案。
---
 PlayTools.xcodeproj/project.pbxproj           |   4 +
 PlayTools/Controls/ActionDispatcher.swift     |  78 ++-
 .../Controls/Backend/Action/PlayAction.swift  | 564 ++++++++++++++++--
 PlayTools/Controls/MenuController.swift       |  52 +-
 .../Editor/Controllers/EditorController.swift | 114 +++-
 .../Elements/ElementController.swift          |   3 +
 .../Elements/Instances/Button.swift           | 250 +++++++-
 .../Elements/Instances/DraggableButton.swift  |  12 +-
 .../Editor/Models/Elements/Element.swift      |  20 +
 PlayTools/Editor/Views/EditorCircleMenu.swift |   7 +-
 .../Editor/Views/Elements/ElementView.swift   |  77 +++
 PlayTools/Editor/Views/KeymapHUDView.swift    | 178 ++++++
 PlayTools/Keymap/Keymapping.swift             |  12 +
 PlayTools/Utils/Toast.swift                   |   7 +
 PlayTools/en.lproj/Playtools.strings          | Bin 6254 -> 8084 bytes
 PlayTools/zh-Hans.lproj/Playtools.strings     | Bin 3414 -> 4838 bytes
 PlayTools/zh-Hant.lproj/Playtools.strings     | Bin 4 -> 1428 bytes
 17 files changed, 1305 insertions(+), 73 deletions(-)
 create mode 100644 PlayTools/Editor/Views/KeymapHUDView.swift

diff --git a/PlayTools.xcodeproj/project.pbxproj b/PlayTools.xcodeproj/project.pbxproj
index 555e944e..70ef16d2 100644
--- a/PlayTools.xcodeproj/project.pbxproj
+++ b/PlayTools.xcodeproj/project.pbxproj
@@ -22,6 +22,7 @@
 		954389CA2B392D7800B063BB /* DraggableButton.swift in Sources */ = {isa = PBXBuildFile; fileRef = 954389C92B392D7800B063BB /* DraggableButton.swift */; };
 		954389CC2B39F03D00B063BB /* EditorView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 954389CB2B39F03D00B063BB /* EditorView.swift */; };
 		954389CE2B39F26600B063BB /* ElementView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 954389CD2B39F26600B063BB /* ElementView.swift */; };
+		954389D42B3A6CD000B063BB /* KeymapHUDView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 954389D52B3A6CD000B063BB /* KeymapHUDView.swift */; };
 		954389D22B3A5AE100B063BB /* ElementController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 954389D12B3A5AE100B063BB /* ElementController.swift */; };
 		9555ED2F2C058E08006E469C /* DebugView.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9555ED2E2C058E08006E469C /* DebugView.swift */; };
 		9555ED312C058E28006E469C /* DebugModel.swift in Sources */ = {isa = PBXBuildFile; fileRef = 9555ED302C058E28006E469C /* DebugModel.swift */; };
@@ -118,6 +119,7 @@
 		954389C72B392D5300B063BB /* Button.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Button.swift; sourceTree = "<group>"; };
 		954389C92B392D7800B063BB /* DraggableButton.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DraggableButton.swift; sourceTree = "<group>"; };
 		954389CB2B39F03D00B063BB /* EditorView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = EditorView.swift; sourceTree = "<group>"; };
+		954389D52B3A6CD000B063BB /* KeymapHUDView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = KeymapHUDView.swift; sourceTree = "<group>"; };
 		954389CD2B39F26600B063BB /* ElementView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ElementView.swift; sourceTree = "<group>"; };
 		954389D12B3A5AE100B063BB /* ElementController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ElementController.swift; sourceTree = "<group>"; };
 		9555ED2E2C058E08006E469C /* DebugView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DebugView.swift; sourceTree = "<group>"; };
@@ -237,6 +239,7 @@
 				AA71978C287A481500623C15 /* CircleMenu */,
 				AA71979D287A481500623C15 /* EditorCircleMenu.swift */,
 				954389CB2B39F03D00B063BB /* EditorView.swift */,
+				954389D52B3A6CD000B063BB /* KeymapHUDView.swift */,
 			);
 			path = Views;
 			sourceTree = "<group>";
@@ -727,6 +730,7 @@
 				954389C22B38922400B063BB /* MouseArea.swift in Sources */,
 				AA7197AB287A481500623C15 /* Element.swift in Sources */,
 				AA7197AE287A481500623C15 /* EditorCircleMenu.swift in Sources */,
+				954389D42B3A6CD000B063BB /* KeymapHUDView.swift in Sources */,
 				954389D22B3A5AE100B063BB /* ElementController.swift in Sources */,
 				95D474FF2C0BDAB20072797F /* DraggableButtonElement.swift in Sources */,
 				9562D1622AB4FE73002C329D /* CameraControlMouseEventAdapter.swift in Sources */,
diff --git a/PlayTools/Controls/ActionDispatcher.swift b/PlayTools/Controls/ActionDispatcher.swift
index 159656c2..4f9414b2 100644
--- a/PlayTools/Controls/ActionDispatcher.swift
+++ b/PlayTools/Controls/ActionDispatcher.swift
@@ -25,7 +25,7 @@ public class ActionDispatcher {
 
     static private let priorityCount = 3
     // You can't put more than 8 cameras or 8 joysticks in a keymap right?
-    static private let mappingCountPerPriority = 8
+    static private let mappingCountPerPriority = 16
     static private let directionPadHandlers: [[ManagedAtomic<AtomicHandler>]] = Array(
         (0..<priorityCount).map({_ in
             (0..<mappingCountPerPriority).map({_ in ManagedAtomic<AtomicHandler>(.EMPTY)})
@@ -51,6 +51,9 @@ public class ActionDispatcher {
         clear()
 
         actions.append(FakeMouseAction())
+        if ShoulderKeymapSwitchAction.isEnabled {
+            actions.append(ShoulderKeymapSwitchAction())
+        }
 
         // current keymap version is 2.0.x.
         // in future, keymap format will be upgraded.
@@ -85,6 +88,10 @@ public class ActionDispatcher {
             actions.append(TriggeredSwipeAction(data: swipe))
         }
 
+        for radialSelector in keymap.currentKeymap.radialSelectorModels {
+            actions.append(RadialSelectorAction(data: radialSelector))
+        }
+
         for joystick in keymap.currentKeymap.joystickModel {
             // Left Thumbstick, Right Thumbstick, Mouse
             if JoystickModel.isAnalog(joystick) {
@@ -118,8 +125,16 @@ public class ActionDispatcher {
     static public func register(key: String,
                                 handler: @escaping (CGFloat, CGFloat) -> Void,
                                 priority: ActionDispatchPriority = .DEFAULT) {
-        let atomicHandler = directionPadHandlers[priority.rawValue].first(where: { handler in
-            handler.load(ordering: .relaxed).key == key
+        register(key: key, modifierKeys: [], handler: handler, priority: priority)
+    }
+
+    static public func register(key: String,
+                                modifierKeys: [String],
+                                handler: @escaping (CGFloat, CGFloat) -> Void,
+                                priority: ActionDispatchPriority = .DEFAULT) {
+        let atomicHandler = directionPadHandlers[priority.rawValue].first(where: { storedHandler in
+            let handlerValue = storedHandler.load(ordering: .relaxed)
+            return handlerValue.key == key && handlerValue.modifierKeys == modifierKeys
         }) ??
         directionPadHandlers[priority.rawValue].first(where: { handler in
             handler.load(ordering: .relaxed).key.isEmpty
@@ -131,7 +146,7 @@ public class ActionDispatcher {
 //            Toast.showHint(title: "register",
 //               text: ["key: \(key), atomicHandler: \(String(describing: atomicHandler))"])
 //        }
-        atomicHandler?.store(AtomicHandler(key, handler), ordering: .releasing)
+        atomicHandler?.store(AtomicHandler(key, modifierKeys, handler), ordering: .releasing)
     }
 
     static public func unregister(key: String) {
@@ -184,16 +199,26 @@ public class ActionDispatcher {
     }
 
     static public func getDispatchPriority(key: String) -> ActionDispatchPriority? {
-        if let priority = directionPadHandlers.firstIndex(where: { handlers in
-            handlers.contains(where: { handler in
-                handler.load(ordering: .acquiring).key == key
-            })
-        }) {
-//            Toast.showHint(title: "\(key) priority", text: ["\(priority)"])
-            return ActionDispatchPriority(rawValue: priority)
+        for priority in 0..<priorityCount {
+            let handlers = directionPadHandlers[priority]
+                .map { $0.load(ordering: .acquiring) }
+                .filter { $0.key == key }
+            guard !handlers.isEmpty else {
+                continue
+            }
+
+            let modifiedHandlers = handlers.filter { handler in
+                !handler.modifierKeys.isEmpty && isPressed(anyOf: handler.modifierKeys)
+            }
+            if !modifiedHandlers.isEmpty || handlers.contains(where: { $0.modifierKeys.isEmpty }) {
+                return ActionDispatchPriority(rawValue: priority)
+            }
         }
 
-        if buttonHandlers[key] != nil {
+        if let handlers = buttonHandlers[key],
+           handlers.contains(where: { handler in
+               handler.modifierKeys.isEmpty || isPressed(anyOf: handler.modifierKeys)
+           }) {
             return .DEFAULT
         }
         return nil
@@ -229,14 +254,27 @@ public class ActionDispatcher {
 
     static public func dispatch(key: String, valueX: CGFloat, valueY: CGFloat) -> Bool {
         for priority in 0..<priorityCount {
-            if let handler = directionPadHandlers[priority].first(where: { handler in
-                handler.load(ordering: .acquiring).key == key
-            }) {
+            let handlers = directionPadHandlers[priority]
+                .map { $0.load(ordering: .acquiring) }
+                .filter { $0.key == key }
+            guard !handlers.isEmpty else {
+                continue
+            }
+            let modifiedHandlers = handlers.filter { handler in
+                !handler.modifierKeys.isEmpty && isPressed(anyOf: handler.modifierKeys)
+            }
+            let selectedHandlers = modifiedHandlers.isEmpty
+                ? handlers.filter { $0.modifierKeys.isEmpty }
+                : modifiedHandlers
+            guard !selectedHandlers.isEmpty else {
+                continue
+            }
+            for handler in selectedHandlers {
                 PlayInput.touchQueue.async(qos: .userInteractive, execute: {
-                    handler.load(ordering: .relaxed).handle(valueX, valueY)
+                    handler.handle(valueX, valueY)
                 })
-                return true
             }
+            return true
         }
         return false
     }
@@ -248,11 +286,13 @@ private struct ButtonPressHandler {
 }
 
 private final class AtomicHandler: AtomicReference {
-    static fileprivate let EMPTY = AtomicHandler("", {_, _ in })
+    static fileprivate let EMPTY = AtomicHandler("", [], {_, _ in })
     let key: String
+    let modifierKeys: [String]
     let handle: (CGFloat, CGFloat) -> Void
-    init(_ key: String, _ handle: @escaping (CGFloat, CGFloat) -> Void) {
+    init(_ key: String, _ modifierKeys: [String], _ handle: @escaping (CGFloat, CGFloat) -> Void) {
         self.key = key
+        self.modifierKeys = modifierKeys
         self.handle = handle
     }
 }
diff --git a/PlayTools/Controls/Backend/Action/PlayAction.swift b/PlayTools/Controls/Backend/Action/PlayAction.swift
index 32dee765..a2835737 100644
--- a/PlayTools/Controls/Backend/Action/PlayAction.swift
+++ b/PlayTools/Controls/Backend/Action/PlayAction.swift
@@ -5,6 +5,7 @@
 
 // swiftlint:disable file_length
 import Foundation
+import UIKit
 
 protocol Action {
     func invalidate()
@@ -13,9 +14,12 @@ protocol Action {
 
 class ButtonAction: Action {
     func invalidate() {
-        isPressed = false
-        Toucher.touchcam(point: point, phase: UITouch.Phase.ended, tid: &id,
-                         actionName: "Button", keyName: keyName)
+        keyIsPressed = false
+        cancelPendingHold()
+        if touchIsActive {
+            touchIsActive = false
+            releaseTouch()
+        }
     }
 
     let keyCode: Int
@@ -23,20 +27,25 @@ class ButtonAction: Action {
     let modifierKeyCode: Int?
     let modifierKeyName: String?
     private let modifierKeys: [String]
+    private let holdDuration: CGFloat?
     let point: CGPoint
     var id: Int?
-    private var isPressed = false
+    private var keyIsPressed = false
+    private var touchIsActive = false
+    private var pendingHold: DispatchWorkItem?
 
     init(keyCode: Int,
          keyName: String,
          modifierKeyCode: Int? = nil,
          modifierKeyName: String? = nil,
+         holdDuration: CGFloat? = nil,
          point: CGPoint) {
         self.keyCode = keyCode
         self.keyName = keyName
         self.modifierKeyCode = modifierKeyCode
         self.modifierKeyName = modifierKeyName
         self.modifierKeys = Self.dispatchNames(code: modifierKeyCode, name: modifierKeyName)
+        self.holdDuration = holdDuration
         self.point = point
         // TODO: set both key names in draggable button, so as to depracate key code
         for key in Self.dispatchNames(code: keyCode, name: keyName) {
@@ -54,6 +63,7 @@ class ButtonAction: Action {
             keyName: data.keyName,
             modifierKeyCode: data.modifierKeyCode,
             modifierKeyName: data.modifierKeyName,
+            holdDuration: data.holdDuration,
             point: CGPoint(
                 x: data.transform.xCoord.absoluteX,
                 y: data.transform.yCoord.absoluteY))
@@ -61,28 +71,67 @@ class ButtonAction: Action {
 
     func update(pressed: Bool) {
         if pressed {
-            guard !isPressed else {
+            guard !keyIsPressed else {
                 return
             }
-            isPressed = true
-            Toucher.touchcam(point: point, phase: UITouch.Phase.began, tid: &id,
-                             actionName: "Button", keyName: keyName)
+            keyIsPressed = true
+            beginAfterHoldIfNeeded()
         } else {
-            guard isPressed else {
+            guard keyIsPressed else {
                 return
             }
-            isPressed = false
-            Toucher.touchcam(point: point, phase: UITouch.Phase.ended, tid: &id,
-                             actionName: "Button", keyName: keyName)
+            keyIsPressed = false
+            cancelPendingHold()
+            if touchIsActive {
+                touchIsActive = false
+                releaseTouch()
+            }
         }
     }
 
     private func updateModifier(pressed: Bool) {
-        if !pressed && id != nil {
-            isPressed = false
-            Toucher.touchcam(point: point, phase: UITouch.Phase.ended, tid: &id,
-                             actionName: "Button", keyName: keyName)
+        if !pressed {
+            keyIsPressed = false
+            cancelPendingHold()
+            if touchIsActive {
+                touchIsActive = false
+                releaseTouch()
+            }
+        }
+    }
+
+    private func beginAfterHoldIfNeeded() {
+        guard let holdDuration = holdDuration else {
+            touchIsActive = true
+            beginTouch()
+            return
         }
+        let workItem = DispatchWorkItem { [weak self] in
+            guard let self = self, self.keyIsPressed else {
+                return
+            }
+            self.pendingHold = nil
+            self.touchIsActive = true
+            self.beginTouch()
+        }
+        pendingHold = workItem
+        PlayInput.touchQueue.asyncAfter(deadline: .now() + Double(holdDuration),
+                                        execute: workItem)
+    }
+
+    private func cancelPendingHold() {
+        pendingHold?.cancel()
+        pendingHold = nil
+    }
+
+    func beginTouch() {
+        Toucher.touchcam(point: point, phase: UITouch.Phase.began, tid: &id,
+                         actionName: "Button", keyName: keyName)
+    }
+
+    func releaseTouch() {
+        Toucher.touchcam(point: point, phase: UITouch.Phase.ended, tid: &id,
+                         actionName: "Button", keyName: keyName)
     }
 
     fileprivate static func dispatchNames(code: Int?, name: String?) -> [String] {
@@ -101,15 +150,18 @@ class ButtonAction: Action {
 class TriggeredSwipeAction: Action {
     private let keyName: String
     private let modifierKeys: [String]
+    private let holdDuration: CGFloat?
     private let startPoint: CGPoint
     private let endPoint: CGPoint
     private var keyIsPressed = false
+    private var pendingHold: DispatchWorkItem?
     private var id: Int?
 
     init(data: Swipe) {
         self.keyName = data.keyName
         self.modifierKeys = ButtonAction.dispatchNames(code: data.modifierKeyCode,
                                                        name: data.modifierKeyName)
+        self.holdDuration = data.holdDuration
         self.startPoint = CGPoint(
             x: data.transform.xCoord.absoluteX,
             y: data.transform.yCoord.absoluteY)
@@ -132,18 +184,42 @@ class TriggeredSwipeAction: Action {
                 return
             }
             keyIsPressed = true
-            performSwipe()
+            performAfterHoldIfNeeded()
         } else {
             keyIsPressed = false
+            cancelPendingHold()
         }
     }
 
     private func updateModifier(pressed: Bool) {
         if !pressed {
             keyIsPressed = false
+            cancelPendingHold()
         }
     }
 
+    private func performAfterHoldIfNeeded() {
+        guard let holdDuration = holdDuration else {
+            performSwipe()
+            return
+        }
+        let workItem = DispatchWorkItem { [weak self] in
+            guard let self = self, self.keyIsPressed else {
+                return
+            }
+            self.pendingHold = nil
+            self.performSwipe()
+        }
+        pendingHold = workItem
+        PlayInput.touchQueue.asyncAfter(deadline: .now() + Double(holdDuration),
+                                        execute: workItem)
+    }
+
+    private func cancelPendingHold() {
+        pendingHold?.cancel()
+        pendingHold = nil
+    }
+
     private func performSwipe() {
         guard id == nil else {
             return
@@ -183,11 +259,415 @@ class TriggeredSwipeAction: Action {
 
     func invalidate() {
         keyIsPressed = false
+        cancelPendingHold()
         Toucher.touchcam(point: endPoint, phase: UITouch.Phase.ended, tid: &id,
                          actionName: "Swipe", keyName: keyName)
     }
 }
 
+enum KeymapSwitchDirection {
+    case next
+    case previous
+}
+
+enum KeymapSwitcher {
+    @discardableResult
+    static func switchKeymap(_ direction: KeymapSwitchDirection) -> Bool {
+        guard Thread.isMainThread else {
+            DispatchQueue.main.async {
+                switchKeymap(direction)
+            }
+            return true
+        }
+
+        guard keymap.keymapCount > 1 else {
+            Toast.showHint(title: NSLocalizedString("hint.keymapping.onlyOneKeymap",
+                                                    tableName: "Playtools",
+                                                    value: "Only one keymap",
+                                                    comment: ""))
+            return false
+        }
+
+        switch direction {
+        case .next:
+            keymap.nextKeymap()
+        case .previous:
+            keymap.previousKeymap()
+        }
+
+        let format = NSLocalizedString("hint.keymapping.switchedKeymap",
+                                       tableName: "Playtools",
+                                       value: "Switched keymap: %@",
+                                       comment: "")
+        Toast.showHint(title: String(format: format, keymap.currentKeymapName))
+        ActionDispatcher.build()
+        EditorController.shared.refreshHUD()
+        return true
+    }
+}
+
+class ShoulderKeymapSwitchAction: Action {
+    static private let userDefaultsKey = "playtools.shoulderKeymapSwitchEnabled"
+    static private let defaultEnabled = true
+
+    static var isEnabled: Bool {
+        get {
+            guard UserDefaults.standard.object(forKey: userDefaultsKey) != nil else {
+                return defaultEnabled
+            }
+            return UserDefaults.standard.bool(forKey: userDefaultsKey)
+        }
+        set {
+            UserDefaults.standard.set(newValue, forKey: userDefaultsKey)
+        }
+    }
+
+    private let cooldown: TimeInterval = 0.3
+    private var lastSwitchDate = Date.distantPast
+
+    init() {
+        let leftShoulder = "Left Shoulder"
+        let rightShoulder = "Right Shoulder"
+        ActionDispatcher.register(key: rightShoulder,
+                                  modifierKeys: [leftShoulder],
+                                  handler: { [weak self] pressed in
+                                      self?.update(pressed: pressed, direction: .next)
+                                  })
+        ActionDispatcher.register(key: leftShoulder,
+                                  modifierKeys: [rightShoulder],
+                                  handler: { [weak self] pressed in
+                                      self?.update(pressed: pressed, direction: .previous)
+                                  })
+    }
+
+    func invalidate() {}
+
+    private func update(pressed: Bool, direction: KeymapSwitchDirection) {
+        guard pressed else {
+            return
+        }
+        guard Date().timeIntervalSince(lastSwitchDate) >= cooldown else {
+            return
+        }
+        lastSwitchDate = Date()
+
+        KeymapSwitcher.switchKeymap(direction)
+    }
+}
+
+private class RadialSelectorOverlay: UIView {
+    private let wheelSize: CGFloat = 192
+    private let labelSize: CGFloat = 44
+    private let selectorCenter: CGPoint
+    private let targetPoints: [CGPoint]
+    private let wheelContainer = UIView()
+    private let selectionLabel = UILabel()
+    private let labels = RadialSelectorModel.defaultSlots.map { slot -> UILabel in
+        let label = UILabel()
+        label.text = slot.title
+        label.textAlignment = .center
+        label.font = UIFont.systemFont(ofSize: 20, weight: .bold)
+        label.textColor = .white
+        label.backgroundColor = UIColor.black.withAlphaComponent(0.7)
+        label.layer.cornerRadius = 16
+        label.clipsToBounds = true
+        return label
+    }
+    private let targetMarkers: [UILabel]
+
+    init(selectorCenter: CGPoint, targetPoints: [CGPoint]) {
+        self.selectorCenter = selectorCenter
+        self.targetPoints = targetPoints
+        self.targetMarkers = RadialSelectorModel.defaultSlots.enumerated().map { index, slot in
+            let label = UILabel()
+            label.text = slot.title
+            label.textAlignment = .center
+            label.font = UIFont.systemFont(ofSize: 30, weight: .bold)
+            label.textColor = .white
+            label.backgroundColor = UIColor.systemTeal.withAlphaComponent(0.8)
+            label.layer.cornerRadius = 28
+            label.clipsToBounds = true
+            label.layer.borderColor = UIColor.white.withAlphaComponent(0.5).cgColor
+            label.layer.borderWidth = 3
+            if !targetPoints.indices.contains(index) {
+                label.isHidden = true
+            }
+            return label
+        }
+        super.init(frame: screen.screenRect)
+        backgroundColor = UIColor.clear
+        isUserInteractionEnabled = false
+        wheelContainer.backgroundColor = UIColor.black.withAlphaComponent(0.5)
+        wheelContainer.layer.cornerRadius = wheelSize / 2
+        wheelContainer.layer.borderColor = UIColor.systemTeal.withAlphaComponent(0.9).cgColor
+        wheelContainer.layer.borderWidth = 3
+        wheelContainer.frame = CGRect(
+            x: selectorCenter.x - wheelSize / 2,
+            y: selectorCenter.y - wheelSize / 2,
+            width: wheelSize,
+            height: wheelSize
+        )
+        addSubview(wheelContainer)
+
+        selectionLabel.textAlignment = .center
+        selectionLabel.font = UIFont.systemFont(ofSize: 44, weight: .heavy)
+        selectionLabel.textColor = .white
+        selectionLabel.backgroundColor = UIColor.black.withAlphaComponent(0.55)
+        selectionLabel.layer.cornerRadius = 30
+        selectionLabel.clipsToBounds = true
+        wheelContainer.addSubview(selectionLabel)
+
+        labels.forEach(wheelContainer.addSubview)
+        targetMarkers.forEach(addSubview)
+        update(selectedIndex: nil)
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        wheelContainer.frame = CGRect(
+            x: selectorCenter.x - wheelSize / 2,
+            y: selectorCenter.y - wheelSize / 2,
+            width: wheelSize,
+            height: wheelSize
+        )
+        selectionLabel.frame = CGRect(x: 48, y: 66, width: 96, height: 60)
+
+        let center = CGPoint(x: wheelContainer.bounds.midX, y: wheelContainer.bounds.midY)
+        let radius: CGFloat = 66
+        for (index, label) in labels.enumerated() {
+            let angle = RadialSelectorModel.defaultSlots[index].angle
+            label.frame = CGRect(
+                x: center.x + cos(angle) * radius - labelSize / 2,
+                y: center.y + sin(angle) * radius - labelSize / 2,
+                width: labelSize,
+                height: labelSize
+            )
+            label.layer.cornerRadius = labelSize / 2
+        }
+
+        for (index, marker) in targetMarkers.enumerated() where targetPoints.indices.contains(index) {
+            let point = targetPoints[index]
+            marker.frame = CGRect(x: point.x - 28, y: point.y - 28, width: 56, height: 56)
+        }
+    }
+
+    func update(selectedIndex: Int?) {
+        for (index, label) in labels.enumerated() {
+            let selected = selectedIndex == index
+            label.backgroundColor = selected
+                ? UIColor.systemGreen.withAlphaComponent(0.92)
+                : UIColor.black.withAlphaComponent(0.7)
+            label.alpha = selected ? 1 : 0.28
+            label.transform = selected ? CGAffineTransform(scaleX: 1.35, y: 1.35) : .identity
+        }
+        for (index, marker) in targetMarkers.enumerated() {
+            let selected = selectedIndex == index
+            marker.backgroundColor = selected
+                ? UIColor.systemGreen.withAlphaComponent(0.92)
+                : UIColor.systemTeal.withAlphaComponent(0.8)
+            marker.alpha = selected ? 1 : 0.45
+            marker.transform = selected ? CGAffineTransform(scaleX: 1.35, y: 1.35) : .identity
+        }
+        selectionLabel.text = selectedIndex.flatMap { labels.indices.contains($0) ? labels[$0].text : nil } ?? "RS"
+        selectionLabel.backgroundColor = selectedIndex == nil
+            ? UIColor.black.withAlphaComponent(0.55)
+            : UIColor.systemGreen.withAlphaComponent(0.9)
+        wheelContainer.layer.borderColor = (selectedIndex == nil
+            ? UIColor.systemTeal.withAlphaComponent(0.9)
+            : UIColor.systemGreen.withAlphaComponent(0.95)).cgColor
+    }
+}
+
+class RadialSelectorAction: Action {
+    private let edgeTriggerThreshold: CGFloat = 0.92
+    private let keyName: String
+    private let modifierKeys: [String]
+    private let holdDuration: CGFloat?
+    private let threshold: CGFloat
+    private let points: [CGPoint]
+    private let selectorCenter: CGPoint
+    private var modifierKeyDown = false
+    private var modifierPressed = false
+    private var pendingHold: DispatchWorkItem?
+    private var lastEdgeTriggeredIndex: Int?
+    private var selectedIndex: Int?
+    private weak var overlay: RadialSelectorOverlay?
+
+    init(data: RadialSelector) {
+        self.keyName = data.keyName
+        self.modifierKeys = ButtonAction.dispatchNames(code: data.modifierKeyCode,
+                                                       name: data.modifierKeyName)
+        self.holdDuration = data.holdDuration
+        self.threshold = min(max(data.activationThreshold ?? 0.55, 0.2), 0.35)
+        self.selectorCenter = CGPoint(
+            x: data.transform.xCoord.absoluteX,
+            y: data.transform.yCoord.absoluteY
+        )
+        self.points = data.slots.map {
+            CGPoint(x: $0.target.xCoord.absoluteX, y: $0.target.yCoord.absoluteY)
+        }
+
+        ActionDispatcher.register(key: keyName,
+                                  modifierKeys: modifierKeys,
+                                  handler: self.thumbstickUpdated)
+        for modifierKey in modifierKeys {
+            ActionDispatcher.register(key: modifierKey, handler: self.modifierUpdated)
+        }
+    }
+
+    func invalidate() {
+        modifierKeyDown = false
+        modifierPressed = false
+        cancelPendingHold()
+        lastEdgeTriggeredIndex = nil
+        selectedIndex = nil
+        hideOverlay()
+    }
+
+    private func modifierUpdated(pressed: Bool) {
+        modifierKeyDown = pressed
+        if pressed {
+            startAfterHoldIfNeeded()
+        } else {
+            cancelPendingHold()
+            guard modifierPressed else {
+                return
+            }
+            modifierPressed = false
+            let alreadyTriggered = lastEdgeTriggeredIndex != nil
+            let selectedPoint = selectedIndex.flatMap { points.indices.contains($0) ? points[$0] : nil }
+            lastEdgeTriggeredIndex = nil
+            selectedIndex = nil
+            hideOverlay()
+            guard !alreadyTriggered else {
+                return
+            }
+            guard let selectedPoint = selectedPoint else {
+                return
+            }
+            triggerTap(at: selectedPoint)
+        }
+    }
+
+    private func startAfterHoldIfNeeded() {
+        guard let holdDuration = holdDuration else {
+            activate()
+            return
+        }
+        let workItem = DispatchWorkItem { [weak self] in
+            self?.pendingHold = nil
+            self?.activate()
+        }
+        pendingHold = workItem
+        PlayInput.touchQueue.asyncAfter(deadline: .now() + Double(holdDuration),
+                                        execute: workItem)
+    }
+
+    private func activate() {
+        guard modifierKeyDown else {
+            return
+        }
+        guard !modifierPressed else {
+            return
+        }
+        modifierPressed = true
+        lastEdgeTriggeredIndex = nil
+        showOverlay()
+    }
+
+    private func cancelPendingHold() {
+        pendingHold?.cancel()
+        pendingHold = nil
+    }
+
+    private func thumbstickUpdated(_ valueX: CGFloat, _ valueY: CGFloat) {
+        guard modifierPressed else {
+            return
+        }
+        let magnitude = hypot(valueX, valueY)
+        guard magnitude >= threshold else {
+            selectedIndex = nil
+            lastEdgeTriggeredIndex = nil
+            DispatchQueue.main.async {
+                self.overlay?.update(selectedIndex: nil)
+            }
+            return
+        }
+        let angle = normalizedAngle(atan2(-valueY, valueX))
+        let newIndex = nearestSlotIndex(for: angle)
+        if newIndex != selectedIndex {
+            selectedIndex = newIndex
+            DispatchQueue.main.async {
+                self.overlay?.update(selectedIndex: newIndex)
+            }
+        }
+
+        if magnitude >= edgeTriggerThreshold,
+           lastEdgeTriggeredIndex != newIndex,
+           points.indices.contains(newIndex) {
+            lastEdgeTriggeredIndex = newIndex
+            triggerTap(at: points[newIndex])
+        } else if magnitude < edgeTriggerThreshold {
+            lastEdgeTriggeredIndex = nil
+        }
+    }
+
+    private func normalizedAngle(_ angle: CGFloat) -> CGFloat {
+        let twoPi = CGFloat.pi * 2
+        let remainder = angle.truncatingRemainder(dividingBy: twoPi)
+        return remainder >= 0 ? remainder : remainder + twoPi
+    }
+
+    private func nearestSlotIndex(for angle: CGFloat) -> Int {
+        RadialSelectorModel.defaultSlots.enumerated().min { lhs, rhs in
+            angularDistance(lhs.element.angle, angle) < angularDistance(rhs.element.angle, angle)
+        }?.offset ?? 0
+    }
+
+    private func angularDistance(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat {
+        let twoPi = CGFloat.pi * 2
+        let distance = abs(lhs - rhs).truncatingRemainder(dividingBy: twoPi)
+        return min(distance, twoPi - distance)
+    }
+
+    private func triggerTap(at point: CGPoint) {
+        var touchId: Int?
+        Toucher.touchcam(point: point, phase: .began, tid: &touchId,
+                         actionName: "RadialSelector", keyName: keyName)
+        PlayInput.touchQueue.asyncAfter(deadline: .now() + 0.05, qos: .userInteractive) {
+            Toucher.touchcam(point: point, phase: .ended, tid: &touchId,
+                             actionName: "RadialSelector", keyName: self.keyName)
+        }
+    }
+
+    private func showOverlay() {
+        DispatchQueue.main.async {
+            if let overlay = self.overlay {
+                overlay.isHidden = false
+                overlay.center = self.selectorCenter
+                overlay.update(selectedIndex: self.selectedIndex)
+                return
+            }
+            let overlay = RadialSelectorOverlay(selectorCenter: self.selectorCenter,
+                                                targetPoints: self.points)
+            overlay.update(selectedIndex: self.selectedIndex)
+            screen.keyWindow?.addSubview(overlay)
+            self.overlay = overlay
+        }
+    }
+
+    private func hideOverlay() {
+        DispatchQueue.main.async {
+            self.overlay?.removeFromSuperview()
+            self.overlay = nil
+        }
+    }
+}
+
 class DraggableButtonAction: ButtonAction {
     var releasePoint: CGPoint
 
@@ -195,6 +675,7 @@ class DraggableButtonAction: ButtonAction {
                   keyName: String,
                   modifierKeyCode: Int? = nil,
                   modifierKeyName: String? = nil,
+                  holdDuration: CGFloat? = nil,
                   point: CGPoint) {
         self.releasePoint = point
         super.init(
@@ -202,28 +683,41 @@ class DraggableButtonAction: ButtonAction {
             keyName: keyName,
             modifierKeyCode: modifierKeyCode,
             modifierKeyName: modifierKeyName,
+            holdDuration: holdDuration,
             point: point)
     }
 
-    override func update(pressed: Bool) {
-        if pressed {
-            Toucher.touchcam(point: point, phase: UITouch.Phase.began, tid: &id,
-                             actionName: "DraggableButton", keyName: keyName)
-            self.releasePoint = point
-            ActionDispatcher.register(key: keyName,
-                                      handler: self.onMouseMoved,
-                                      priority: .DRAGGABLE)
+    convenience init(data: Button) {
+        self.init(
+            keyCode: data.keyCode,
+            keyName: data.keyName,
+            modifierKeyCode: data.modifierKeyCode,
+            modifierKeyName: data.modifierKeyName,
+            holdDuration: data.holdDuration,
+            point: CGPoint(
+                x: data.transform.xCoord.absoluteX,
+                y: data.transform.yCoord.absoluteY))
+    }
+
+    override func beginTouch() {
+        Toucher.touchcam(point: point, phase: UITouch.Phase.began, tid: &id,
+                         actionName: "DraggableButton", keyName: keyName)
+        self.releasePoint = point
+        ActionDispatcher.register(key: keyName,
+                                  handler: self.onMouseMoved,
+                                  priority: .DRAGGABLE)
+        if keyName == KeyCodeNames.mouseMove && !mode.cursorHidden() {
+            AKInterface.shared!.hideCursor()
+        }
+    }
+
+    override func releaseTouch() {
+        Toucher.touchcam(point: releasePoint, phase: UITouch.Phase.ended, tid: &id,
+                         actionName: "DraggableButton", keyName: keyName)
+        if id == nil {
+            ActionDispatcher.unregister(key: keyName)
             if keyName == KeyCodeNames.mouseMove && !mode.cursorHidden() {
-                AKInterface.shared!.hideCursor()
-            }
-        } else {
-            Toucher.touchcam(point: releasePoint, phase: UITouch.Phase.ended, tid: &id,
-                             actionName: "DraggableButton", keyName: keyName)
-            if id == nil {
-                ActionDispatcher.unregister(key: keyName)
-                if keyName == KeyCodeNames.mouseMove && !mode.cursorHidden() {
-                    AKInterface.shared!.unhideCursor()
-                }
+                AKInterface.shared!.unhideCursor()
             }
         }
     }
diff --git a/PlayTools/Controls/MenuController.swift b/PlayTools/Controls/MenuController.swift
index d60c4315..d2f132b3 100644
--- a/PlayTools/Controls/MenuController.swift
+++ b/PlayTools/Controls/MenuController.swift
@@ -30,6 +30,11 @@ extension UIApplication {
         ModeAutomaton.onCmdK()
     }
 
+    @objc
+    func toggleKeymapHUD(_ sender: AnyObject) {
+        EditorController.shared.toggleHUD()
+    }
+
     @objc
     func removeElement(_ sender: AnyObject) {
         EditorController.shared.removeControl()
@@ -60,6 +65,27 @@ extension UIApplication {
         EditorController.shared.cycleSwipeDirection()
     }
 
+    @objc
+    func toggleElementHoldTrigger(_ sender: AnyObject) {
+        EditorController.shared.toggleHoldTrigger()
+    }
+
+    @objc
+    func toggleShoulderKeymapSwitch(_ sender: AnyObject) {
+        ShoulderKeymapSwitchAction.isEnabled.toggle()
+        let titleKey = ShoulderKeymapSwitchAction.isEnabled
+            ? "hint.keymapping.shoulderSwitch.enabled"
+            : "hint.keymapping.shoulderSwitch.disabled"
+        let fallback = ShoulderKeymapSwitchAction.isEnabled
+            ? "Shoulder keymap switch enabled"
+            : "Shoulder keymap switch disabled"
+        Toast.showHint(title: NSLocalizedString(titleKey,
+                                                tableName: "Playtools",
+                                                value: fallback,
+                                                comment: ""))
+        ActionDispatcher.build()
+    }
+
     // put a mark in the toucher log, so as to align with tester description
     @objc
     func markToucherLog(_ sender: AnyObject) {
@@ -103,9 +129,7 @@ extension UIApplication {
             ModeAutomaton.onCmdK()
         }
 
-        keymap.nextKeymap()
-        Toast.showHint(title: "Switched to next keymap: \(keymap.currentKeymapName)")
-        ActionDispatcher.build()
+        KeymapSwitcher.switchKeymap(.next)
 
         if isCmdK {
             ModeAutomaton.onCmdK()
@@ -120,9 +144,7 @@ extension UIApplication {
             ModeAutomaton.onCmdK()
         }
 
-        keymap.previousKeymap()
-        Toast.showHint(title: "Switched to previous keymap: \(keymap.currentKeymapName)")
-        ActionDispatcher.build()
+        KeymapSwitcher.switchKeymap(.previous)
 
         if isCmdK {
             ModeAutomaton.onCmdK()
@@ -150,6 +172,8 @@ struct CommandsList {
 var keymapping = [
     NSLocalizedString("menu.keymapping.toggleEditor", tableName: "Playtools",
                       value: "Open/Close Keymapping Editor", comment: ""),
+    NSLocalizedString("menu.keymapping.toggleHUD", tableName: "Playtools",
+                      value: "Show/Hide Keymap HUD", comment: ""),
     NSLocalizedString("menu.keymapping.deleteElement", tableName: "Playtools",
                       value: "Delete selected element", comment: ""),
     NSLocalizedString("menu.keymapping.upsizeElement", tableName: "Playtools",
@@ -162,6 +186,10 @@ var keymapping = [
                       value: "Clear selected button modifier", comment: ""),
     NSLocalizedString("menu.keymapping.cycleSwipeDirection", tableName: "Playtools",
                       value: "Switch selected swipe direction", comment: ""),
+    NSLocalizedString("menu.keymapping.toggleHoldTrigger", tableName: "Playtools",
+                      value: "Toggle selected long-press trigger", comment: ""),
+    NSLocalizedString("menu.keymapping.toggleShoulderKeymapSwitch", tableName: "Playtools",
+                      value: "Toggle shoulder keymap switch", comment: ""),
     NSLocalizedString("menu.keymapping.toggleDebug", tableName: "Playtools",
                       value: "Toggle Debug Overlay", comment: ""),
     NSLocalizedString("menu.keymapping.hide.pointer", tableName: "Playtools",
@@ -173,24 +201,30 @@ var keymapping = [
   ]
 var iconsSelctor = [
     UIImage(systemName: "pencil"),
+    UIImage(systemName: "eye"),
     UIImage(systemName: "trash.fill"),
     UIImage(systemName: "square.resize.up"),
     UIImage(systemName: "square.resize.down"),
     UIImage(systemName: "command"),
     UIImage(systemName: "command.circle"),
     UIImage(systemName: "arrow.triangle.2.circlepath"),
+    UIImage(systemName: "timer"),
+    UIImage(systemName: "gamecontroller"),
     UIImage(systemName: "wrench.and.screwdriver"),
     UIImage(systemName: "pointer.arrow.slash"),
     UIImage(systemName: "arrow.down.square"),
     UIImage(systemName: "arrow.up.square")
   ]
 var keymappingSelectors = [#selector(UIApplication.switchEditorMode(_:)),
+                           #selector(UIApplication.toggleKeymapHUD(_:)),
                            #selector(UIApplication.removeElement(_:)),
                            #selector(UIApplication.upscaleElement(_:)),
                            #selector(UIApplication.downscaleElement(_:)),
                            #selector(UIApplication.captureElementModifierKey(_:)),
                            #selector(UIApplication.clearElementModifierKey(_:)),
                            #selector(UIApplication.cycleSwipeDirection(_:)),
+                           #selector(UIApplication.toggleElementHoldTrigger(_:)),
+                           #selector(UIApplication.toggleShoulderKeymapSwitch(_:)),
                            #selector(UIApplication.toggleDebugOverlay(_:)),
                            #selector(UIApplication.hideCursor(_:)),
                            #selector(UIApplication.previousKeymap(_:)),
@@ -257,12 +291,15 @@ class MenuController {
     class func keymappingMenu() -> UIMenu {
         let keyCommands = [
             "K",                            // Toggle keymap editor
+            "K",                            // Toggle keymap HUD
             UIKeyCommand.inputDelete,       // Remove keymap element
             UIKeyCommand.inputUpArrow,      // Increase keymap element size
             UIKeyCommand.inputDownArrow,    // Decrease keymap element size
             "M",                            // Set button modifier
             "M",                            // Clear button modifier
             "R",                            // Switch swipe direction
+            "L",                            // Toggle long-press trigger
+            "B",                            // Toggle shoulder keymap switch
             "D",                            // Toggle debug overlay
             ".",                            // Hide cursor until move
             "[",                            // Previous keymap
@@ -270,6 +307,7 @@ class MenuController {
         ]
         let keyModifiers: [UIKeyModifierFlags] = [
             .command,
+            [.command, .shift],
             .command,
             .command,
             .command,
@@ -277,6 +315,8 @@ class MenuController {
             [.command, .shift],
             .command,
             .command,
+            [.command, .shift],
+            .command,
             .command,
             .command,
             .command
diff --git a/PlayTools/Editor/Controllers/EditorController.swift b/PlayTools/Editor/Controllers/EditorController.swift
index 9f995253..61c13917 100644
--- a/PlayTools/Editor/Controllers/EditorController.swift
+++ b/PlayTools/Editor/Controllers/EditorController.swift
@@ -3,6 +3,7 @@ import SwiftUI
 
 let editor = EditorController.shared
 
+// swiftlint:disable type_body_length
 class EditorController {
 
     static let shared = EditorController()
@@ -18,6 +19,7 @@ class EditorController {
     private var keyCaptureMode = KeyCaptureMode.primary
 
     var editorWindow: UIWindow?
+    private var hudWindow: KeymapHUDWindow?
     weak var previousWindow: UIWindow?
     var controls: [ControlElement] = []
     var view: EditorView! {editorWindow?.rootViewController?.view as? EditorView}
@@ -31,6 +33,9 @@ class EditorController {
     private func addControlToView(control: ControlElement) {
         controls.append(control)
         view.addSubview(control.button)
+        if let radialSelector = control as? RadialSelectorModel {
+            radialSelector.slotControls.forEach { view.addSubview($0.button) }
+        }
         updateFocus(button: control.button)
     }
 
@@ -81,6 +86,47 @@ class EditorController {
     }
 
     var editorMode: Bool { !(editorWindow?.isHidden ?? true)}
+    var hudVisible: Bool { !(hudWindow?.isHidden ?? true)}
+
+    public func toggleHUD() {
+        if hudVisible {
+            hideHUD()
+        } else {
+            showHUD()
+        }
+    }
+
+    public func refreshHUD() {
+        guard hudVisible else {
+            return
+        }
+        hudWindow?.rootViewController?.view = KeymapHUDView(map: keymap.currentKeymap)
+    }
+
+    private func showHUD() {
+        guard let windowScene = screen.windowScene else {
+            return
+        }
+        let window = KeymapHUDWindow(windowScene: windowScene)
+        window.rootViewController?.view = KeymapHUDView(map: keymap.currentKeymap)
+        window.isHidden = false
+        hudWindow = window
+        Toast.showHint(title: NSLocalizedString("hint.keymappingHUD.shown",
+                                                tableName: "Playtools",
+                                                value: "Keymap HUD shown",
+                                                comment: ""))
+    }
+
+    private func hideHUD() {
+        hudWindow?.isHidden = true
+        hudWindow?.windowScene = nil
+        hudWindow?.rootViewController = nil
+        hudWindow = nil
+        Toast.showHint(title: NSLocalizedString("hint.keymappingHUD.hidden",
+                                                tableName: "Playtools",
+                                                value: "Keymap HUD hidden",
+                                                comment: ""))
+    }
 
     public func setKey(_ code: Int) {
         if editorMode {
@@ -102,14 +148,20 @@ class EditorController {
             }
             if name != "Mouse" || focusedControl is MouseAreaModel
                 || focusedControl is JoystickModel
-                || focusedControl is DraggableButtonModel {
+                || focusedControl is DraggableButtonModel
+                || focusedControl is RadialSelectorModel
+                || focusedControl is RadialSelectorSlotControl {
                 focusedControl?.setKey(name: name)
             }
         }
     }
 
     public func captureModifierKey() {
-        guard editorMode, focusedControl is ButtonModel || focusedControl is SwipeModel else {
+        guard editorMode,
+              focusedControl is ButtonModel
+                || focusedControl is SwipeModel
+                || focusedControl is RadialSelectorModel
+                || focusedControl is RadialSelectorSlotControl else {
             Toast.showHint(
                 title: NSLocalizedString("hint.keymappingEditor.selectButton.title",
                                          tableName: "Playtools",
@@ -137,7 +189,12 @@ class EditorController {
     }
 
     public func clearModifierKey() {
-        guard editorMode, focusedControl is ButtonModel || focusedControl is SwipeModel else {
+        guard editorMode,
+              focusedControl is ButtonModel
+                || focusedControl is DraggableButtonModel
+                || focusedControl is SwipeModel
+                || focusedControl is RadialSelectorModel
+                || focusedControl is RadialSelectorSlotControl else {
             Toast.showHint(
                 title: NSLocalizedString("hint.keymappingEditor.selectButton.title",
                                          tableName: "Playtools",
@@ -159,6 +216,27 @@ class EditorController {
                                                 comment: ""))
     }
 
+    public func toggleHoldTrigger() {
+        guard editorMode,
+              focusedControl is ButtonModel
+                || focusedControl is DraggableButtonModel
+                || focusedControl is SwipeModel
+                || focusedControl is RadialSelectorModel
+                || focusedControl is RadialSelectorSlotControl else {
+            Toast.showHint(title: NSLocalizedString("hint.keymappingEditor.selectHoldTrigger.title",
+                                                    tableName: "Playtools",
+                                                    value: "Select a button, swipe, or radial selector first",
+                                                    comment: ""))
+            return
+        }
+        focusedControl?.toggleHoldTrigger()
+        keyCaptureMode = .primary
+        Toast.showHint(title: NSLocalizedString("hint.keymappingEditor.holdTriggerToggled.title",
+                                                tableName: "Playtools",
+                                                value: "Long-press trigger toggled",
+                                                comment: ""))
+    }
+
     private func finishModifierCapture() {
         keyCaptureMode = .primary
         Toast.showHint(
@@ -175,6 +253,12 @@ class EditorController {
 
     public func removeControl() {
         keyCaptureMode = .primary
+        if let radialSlot = focusedControl as? RadialSelectorSlotControl {
+            controls = controls.filter { $0 !== radialSlot.parent }
+            radialSlot.parent.remove()
+            focusedControl = nil
+            return
+        }
         controls = controls.filter { $0 !== focusedControl }
         focusedControl?.remove()
     }
@@ -214,6 +298,10 @@ class EditorController {
             let ctrl = SwipeModel(data: swipe)
             addControlToView(control: ctrl)
         }
+        for radialSelector in keymap.currentKeymap.radialSelectorModels {
+            let ctrl = RadialSelectorModel(data: radialSelector)
+            addControlToView(control: ctrl)
+        }
         for button in keymap.currentKeymap.buttonModels {
             let ctrl = ButtonModel(data: button)
             addControlToView(control: ctrl)
@@ -233,6 +321,8 @@ class EditorController {
                 keymapData.mouseAreaModel.append(model.save())
             case let model as SwipeModel:
                 keymapData.swipeModels.append(model.save())
+            case let model as RadialSelectorModel:
+                keymapData.radialSelectorModels.append(model.save())
             case let model as ButtonModel:
                 keymapData.buttonModels.append(model.save())
             default:
@@ -324,6 +414,23 @@ class EditorController {
         }
     }
 
+    public func addRadialSelector(_ center: CGPoint) {
+        if editorMode {
+            let size = CGFloat(12)
+            addControlToView(control: RadialSelectorModel(data: RadialSelector(
+                keyCode: KeyCodeNames.defaultCode,
+                keyName: "Right Thumbstick",
+                modifierKeyCode: -12,
+                modifierKeyName: "Left Shoulder",
+                transform: KeyModelTransform(
+                    size: size, xCoord: center.x.relativeX, yCoord: center.y.relativeY
+                ),
+                activationThreshold: 0.35,
+                slots: RadialSelectorModel.makeDefaultSlots(center: center, size: size.absoluteSize)
+            )))
+        }
+    }
+
     public func addDraggableButton(_ center: CGPoint, _ keyCode: Int) {
         if editorMode {
             addControlToView(control: DraggableButtonModel(data: Button(
@@ -340,3 +447,4 @@ class EditorController {
         view.label?.text = str
     }
 }
+// swiftlint:enable type_body_length
diff --git a/PlayTools/Editor/Controllers/Elements/ElementController.swift b/PlayTools/Editor/Controllers/Elements/ElementController.swift
index 31b051c0..6821f0cb 100644
--- a/PlayTools/Editor/Controllers/Elements/ElementController.swift
+++ b/PlayTools/Editor/Controllers/Elements/ElementController.swift
@@ -17,6 +17,7 @@ protocol ControlElement: AnyObject {
     func setModifierKey(name: String)
     func clearModifierKey()
     func cycleDirection()
+    func toggleHoldTrigger()
     func resize(down: Bool)
     func remove()
 }
@@ -83,4 +84,6 @@ class ControlModel<ElementType: BaseElement>: ControlElement {
     func clearModifierKey() {}
 
     func cycleDirection() {}
+
+    func toggleHoldTrigger() {}
 }
diff --git a/PlayTools/Editor/Controllers/Elements/Instances/Button.swift b/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
index bff77e49..d6258590 100644
--- a/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
+++ b/PlayTools/Editor/Controllers/Elements/Instances/Button.swift
@@ -8,7 +8,8 @@
 import Foundation
 
 class ButtonModel: ControlModel<Button> {
-    fileprivate static let shortKeyNames = [
+    static let defaultHoldDuration: CGFloat = 0.5
+    private static let shortKeyNames = [
         "Button Menu": "Menu",
         "Button Options": "Options",
         "Direction Pad Up": "D-Up",
@@ -18,7 +19,9 @@ class ButtonModel: ControlModel<Button> {
         "Left Shoulder": "LB",
         "Left Trigger": "LT",
         "Right Shoulder": "RB",
-        "Right Trigger": "RT"
+        "Right Trigger": "RT",
+        "Left Thumbstick": "LS",
+        "Right Thumbstick": "RS"
     ]
 
     override init(data: Button) {
@@ -56,6 +59,13 @@ class ButtonModel: ControlModel<Button> {
         updateTitle()
     }
 
+    override func toggleHoldTrigger() {
+        var buttonData = data
+        buttonData.holdDuration = buttonData.holdDuration == nil ? Self.defaultHoldDuration : nil
+        data = buttonData
+        updateTitle()
+    }
+
     private func setModifierKey(code: Int, name: String) {
         var buttonData = data
         buttonData.modifierKeyCode = code
@@ -66,15 +76,16 @@ class ButtonModel: ControlModel<Button> {
 
     private func updateTitle() {
         let keyName = Self.displayName(for: data.keyName)
+        let holdPrefix = data.holdDuration == nil ? "" : "Hold\n"
         guard let modifierKeyName = data.modifierKeyName, !modifierKeyName.isEmpty else {
-            button.setTitle(keyName, for: UIControl.State.normal)
+            button.setTitle("\(holdPrefix)\(keyName)", for: UIControl.State.normal)
             return
         }
         let modifierName = Self.displayName(for: modifierKeyName)
-        button.setTitle("\(modifierName)+\n\(keyName)", for: UIControl.State.normal)
+        button.setTitle("\(holdPrefix)\(modifierName)+\n\(keyName)", for: UIControl.State.normal)
     }
 
-    fileprivate static func displayName(for keyName: String) -> String {
+    static func displayName(for keyName: String) -> String {
         shortKeyNames[keyName] ?? keyName
     }
 }
@@ -132,6 +143,13 @@ class SwipeModel: ControlModel<Swipe> {
         updateTitle()
     }
 
+    override func toggleHoldTrigger() {
+        var swipeData = data
+        swipeData.holdDuration = swipeData.holdDuration == nil ? ButtonModel.defaultHoldDuration : nil
+        data = swipeData
+        updateTitle()
+    }
+
     override func cycleDirection() {
         var swipeData = data
         let currentIndex = Self.nearestDirectionIndex(for: swipeData.angle)
@@ -152,13 +170,14 @@ class SwipeModel: ControlModel<Swipe> {
     private func updateTitle() {
         let keyName = ButtonModel.displayName(for: data.keyName)
         let direction = Self.directions[Self.nearestDirectionIndex(for: data.angle)].name
-        let title = "\(direction)\n\(keyName)"
+        let holdPrefix = data.holdDuration == nil ? "" : "Hold\n"
+        let title = "\(holdPrefix)\(direction)\n\(keyName)"
         guard let modifierKeyName = data.modifierKeyName, !modifierKeyName.isEmpty else {
             button.setTitle(title, for: UIControl.State.normal)
             return
         }
         let modifierName = ButtonModel.displayName(for: modifierKeyName)
-        button.setTitle("\(modifierName)+\n\(keyName) \(direction)", for: UIControl.State.normal)
+        button.setTitle("\(holdPrefix)\(modifierName)+\n\(keyName) \(direction)", for: UIControl.State.normal)
     }
 
     private static func nearestDirectionIndex(for angle: CGFloat) -> Int {
@@ -175,3 +194,220 @@ class SwipeModel: ControlModel<Swipe> {
         return min(distance, twoPi - distance)
     }
 }
+
+class RadialSelectorSlotControl: ControlElement {
+    let parent: RadialSelectorModel
+    let index: Int
+    let button: Element
+
+    init(parent: RadialSelectorModel, index: Int) {
+        self.parent = parent
+        self.index = index
+        let target = parent.data.slots[index].target
+        self.button = RadialSelectorSlotElement(
+            frame: CGRect(
+                x: target.xCoord.absoluteX - target.size.absoluteSize / 2,
+                y: target.yCoord.absoluteY - target.size.absoluteSize / 2,
+                width: target.size.absoluteSize,
+                height: target.size.absoluteSize
+            )
+        )
+        self.button.model = self
+        updateTitle()
+    }
+
+    func move(deltaY: CGFloat, deltaX: CGFloat) {
+        var slot = parent.data.slots[index]
+        let newX = button.center.x + deltaX
+        let newY = button.center.y + deltaY
+        if newX > 0 && newX < screen.width {
+            slot.target.xCoord = newX.relativeX
+        }
+        if newY > 0 && newY < screen.height {
+            slot.target.yCoord = newY.relativeY
+        }
+        parent.data.slots[index] = slot
+        button.setCenterXY(newX: newX, newY: newY)
+    }
+
+    func focus(_ focus: Bool) {
+        parent.focusSlot(index: focus ? index : nil)
+    }
+
+    func setKey(code: Int) {
+        parent.setKey(code: code)
+    }
+
+    func setKey(name: String) {
+        parent.setKey(name: name)
+    }
+
+    func setModifierKey(code: Int) {
+        parent.setModifierKey(code: code)
+    }
+
+    func setModifierKey(name: String) {
+        parent.setModifierKey(name: name)
+    }
+
+    func clearModifierKey() {
+        parent.clearModifierKey()
+    }
+
+    func toggleHoldTrigger() {
+        parent.toggleHoldTrigger()
+    }
+
+    func cycleDirection() {}
+
+    func resize(down: Bool) {
+        let mod = down ? 0.9 : 1 / 0.9
+        var slot = parent.data.slots[index]
+        slot.target.size = (slot.target.size.absoluteSize * CGFloat(mod)).relativeSize
+        parent.data.slots[index] = slot
+        refresh()
+    }
+
+    func remove() {
+        button.removeFromSuperview()
+    }
+
+    func refresh() {
+        let slot = parent.data.slots[index]
+        button.setSize(newSize: slot.target.size.absoluteSize)
+        button.setCenterXY(newX: slot.target.xCoord.absoluteX, newY: slot.target.yCoord.absoluteY)
+        updateTitle()
+    }
+
+    private func updateTitle() {
+        let slot = parent.data.slots[index]
+        let title = slot.title ?? RadialSelectorModel.defaultSlots[index].title
+        button.setTitle(title, for: .normal)
+    }
+}
+
+class RadialSelectorModel: ControlModel<RadialSelector> {
+    static let defaultSlots: [(title: String, angle: CGFloat)] = [
+        ("↑", CGFloat.pi * 3 / 2),
+        ("↗", CGFloat.pi * 7 / 4),
+        ("→", 0),
+        ("↘", CGFloat.pi / 4),
+        ("↓", CGFloat.pi / 2),
+        ("↙", CGFloat.pi * 3 / 4),
+        ("←", CGFloat.pi),
+        ("↖", CGFloat.pi * 5 / 4)
+    ]
+
+    var slotControls = [RadialSelectorSlotControl]()
+    private var focusedSlotIndex: Int?
+
+    override init(data: RadialSelector) {
+        super.init(data: data)
+        button.removeFromSuperview()
+        button = RadialSelectorElement(frame: CGRect(
+            x: data.transform.xCoord.absoluteX - data.transform.size.absoluteSize / 2,
+            y: data.transform.yCoord.absoluteY - data.transform.size.absoluteSize / 2,
+            width: data.transform.size.absoluteSize,
+            height: data.transform.size.absoluteSize
+        ))
+        button.model = self
+        for index in data.slots.indices {
+            slotControls.append(RadialSelectorSlotControl(parent: self, index: index))
+        }
+        updateTitle()
+    }
+
+    static func makeDefaultSlots(center: CGPoint, size: CGFloat) -> [RadialSelectorSlot] {
+        let radius = max(size * 0.72, CGFloat(8.5).absoluteSize)
+        let slotSize = CGFloat(2.5).absoluteSize
+        let inset = slotSize / 2 + 8
+        return defaultSlots.map { slot in
+            let rawX = center.x + cos(slot.angle) * radius
+            let rawY = center.y + sin(slot.angle) * radius
+            return RadialSelectorSlot(
+                angle: slot.angle,
+                target: KeyModelTransform(
+                    size: 2.5,
+                    xCoord: min(max(rawX, inset), screen.width - inset).relativeX,
+                    yCoord: min(max(rawY, inset), screen.height - inset).relativeY
+                ),
+                title: slot.title,
+                enabled: true
+            )
+        }
+    }
+
+    func save() -> RadialSelector {
+        data
+    }
+
+    override func remove() {
+        super.remove()
+        slotControls.forEach { $0.remove() }
+    }
+
+    override func focus(_ focus: Bool) {
+        if !focus {
+            focusedSlotIndex = nil
+            slotControls.forEach { $0.button.focus(false) }
+        }
+        button.focus(focus && focusedSlotIndex == nil)
+    }
+
+    func focusSlot(index: Int?) {
+        focusedSlotIndex = index
+        button.focus(index == nil)
+        for (slotIndex, slotControl) in slotControls.enumerated() {
+            slotControl.button.focus(index == slotIndex)
+        }
+    }
+
+    override func move(deltaY: CGFloat, deltaX: CGFloat) {
+        super.move(deltaY: deltaY, deltaX: deltaX)
+        button.update()
+    }
+
+    override func setKey(code: Int, name: String) {
+        guard KeyCodeNames.isThumbstick(name) else {
+            return
+        }
+        data.keyCode = code
+        data.keyName = name
+        updateTitle()
+    }
+
+    override func setModifierKey(code: Int) {
+        setModifierKey(code: code, name: KeyCodeNames.keyCodes[code] ?? "Btn")
+    }
+
+    override func setModifierKey(name: String) {
+        setModifierKey(code: KeyCodeNames.keyCodeByName[name] ?? KeyCodeNames.defaultCode, name: name)
+    }
+
+    override func clearModifierKey() {
+        data.modifierKeyCode = nil
+        data.modifierKeyName = nil
+        updateTitle()
+    }
+
+    override func toggleHoldTrigger() {
+        data.holdDuration = data.holdDuration == nil ? ButtonModel.defaultHoldDuration : nil
+        updateTitle()
+    }
+
+    private func setModifierKey(code: Int, name: String) {
+        data.modifierKeyCode = code
+        data.modifierKeyName = name
+        updateTitle()
+    }
+
+    func updateTitle() {
+        let keyName = ButtonModel.displayName(for: data.keyName)
+        let holdPrefix = data.holdDuration == nil ? "" : "Hold\n"
+        guard let modifierKeyName = data.modifierKeyName, !modifierKeyName.isEmpty else {
+            button.setTitle("\(holdPrefix)\(keyName)", for: .normal)
+            return
+        }
+        button.setTitle("\(holdPrefix)\(ButtonModel.displayName(for: modifierKeyName))+\n\(keyName)", for: .normal)
+    }
+}
diff --git a/PlayTools/Editor/Controllers/Elements/Instances/DraggableButton.swift b/PlayTools/Editor/Controllers/Elements/Instances/DraggableButton.swift
index bbd89e97..d833d366 100644
--- a/PlayTools/Editor/Controllers/Elements/Instances/DraggableButton.swift
+++ b/PlayTools/Editor/Controllers/Elements/Instances/DraggableButton.swift
@@ -42,13 +42,23 @@ class DraggableButtonModel: ControlModel<Button>, ParentElement {
         if code == KeyCodeNames.defaultCode {
             // set the parent key
             self.data.keyName = name
-            button.setTitle(data.keyName, for: UIControl.State.normal)
+            updateTitle()
         } else {
             // set the child key
             childButton!.setKey(code: code)
         }
     }
 
+    override func toggleHoldTrigger() {
+        data.holdDuration = data.holdDuration == nil ? ButtonModel.defaultHoldDuration : nil
+        updateTitle()
+    }
+
+    private func updateTitle() {
+        let holdPrefix = data.holdDuration == nil ? "" : "Hold\n"
+        button.setTitle("\(holdPrefix)\(ButtonModel.displayName(for: data.keyName))", for: .normal)
+    }
+
     override func focus(_ focus: Bool) {
         super.focus(focus)
         if !focus {
diff --git a/PlayTools/Editor/Models/Elements/Element.swift b/PlayTools/Editor/Models/Elements/Element.swift
index 64ed3e62..36500729 100644
--- a/PlayTools/Editor/Models/Elements/Element.swift
+++ b/PlayTools/Editor/Models/Elements/Element.swift
@@ -19,6 +19,7 @@ struct Button: BaseElement {
     var keyName: String
     var modifierKeyCode: Int?
     var modifierKeyName: String?
+    var holdDuration: CGFloat?
     var transform: KeyModelTransform
 }
 
@@ -61,7 +62,26 @@ struct Swipe: BaseElement {
     var keyName: String
     var modifierKeyCode: Int?
     var modifierKeyName: String?
+    var holdDuration: CGFloat?
     var transform: KeyModelTransform
     // [0, 2 * PI)
     var angle: CGFloat
 }
+
+struct RadialSelectorSlot: Codable {
+    var angle: CGFloat
+    var target: KeyModelTransform
+    var title: String?
+    var enabled: Bool
+}
+
+struct RadialSelector: BaseElement {
+    var keyCode: Int
+    var keyName: String
+    var modifierKeyCode: Int?
+    var modifierKeyName: String?
+    var holdDuration: CGFloat?
+    var transform: KeyModelTransform
+    var activationThreshold: CGFloat?
+    var slots: [RadialSelectorSlot]
+}
diff --git a/PlayTools/Editor/Views/EditorCircleMenu.swift b/PlayTools/Editor/Views/EditorCircleMenu.swift
index 0f404157..5f96bddf 100644
--- a/PlayTools/Editor/Views/EditorCircleMenu.swift
+++ b/PlayTools/Editor/Views/EditorCircleMenu.swift
@@ -20,7 +20,7 @@ class EditorCircleMenu: CircleMenuDelegate {
             frame: CGRect(x: 0, y: 0, width: 50, height: 50),
             normalIcon: "xmark.circle.fill",
             selectedIcon: "xmark.circle.fill",
-            buttonsCount: 4,
+            buttonsCount: 5,
             duration: 0.25,
             distance: 80)
         menu?.delegate = self
@@ -58,6 +58,8 @@ class EditorCircleMenu: CircleMenuDelegate {
             EditorController.shared.addMouseArea(globalPoint!)
         case 3:
             EditorController.shared.addSwipe(globalPoint!)
+        case 4:
+            EditorController.shared.addRadialSelector(globalPoint!)
         default:
             Toast.showHint(title: "item \(atIndex) is not recognizable")
 //            EditorController.shared.addMouseJoystick(globalPoint!)
@@ -80,6 +82,7 @@ class EditorCircleMenu: CircleMenuDelegate {
 //          "rb.rectangle.roundedbottom.fill",
 //          "lb.rectangle.roundedbottom",
           "computermouse",
-          "hand.draw"
+          "hand.draw",
+          "scope"
       ]
 }
diff --git a/PlayTools/Editor/Views/Elements/ElementView.swift b/PlayTools/Editor/Views/Elements/ElementView.swift
index ddf07838..d9e12352 100644
--- a/PlayTools/Editor/Views/Elements/ElementView.swift
+++ b/PlayTools/Editor/Views/Elements/ElementView.swift
@@ -153,6 +153,83 @@ class SwipeElement: Element {
     }
 }
 
+class RadialSelectorElement: Element {
+    private let ringLayer = CAShapeLayer()
+    private let activeRingLayer = CAShapeLayer()
+    private var spokeLayers = [CAShapeLayer]()
+
+    override func commonInit() {
+        super.commonInit()
+        backgroundColor = UIColor.black.withAlphaComponent(0.8)
+
+        ringLayer.fillColor = UIColor.clear.cgColor
+        ringLayer.strokeColor = UIColor.systemTeal.withAlphaComponent(0.8).cgColor
+        ringLayer.lineWidth = 3
+
+        activeRingLayer.fillColor = UIColor.systemPink.withAlphaComponent(0.18).cgColor
+        activeRingLayer.strokeColor = UIColor.systemPink.cgColor
+        activeRingLayer.lineWidth = 3
+
+        layer.insertSublayer(activeRingLayer, at: 0)
+        layer.insertSublayer(ringLayer, at: 0)
+        (0..<RadialSelectorModel.defaultSlots.count).forEach { _ in
+            let spoke = CAShapeLayer()
+            spoke.fillColor = UIColor.clear.cgColor
+            spoke.strokeColor = UIColor.white.withAlphaComponent(0.3).cgColor
+            spoke.lineWidth = 2
+            layer.insertSublayer(spoke, at: 0)
+            spokeLayers.append(spoke)
+        }
+        titleLabel?.font = UIFont.systemFont(ofSize: 12, weight: .semibold)
+        update()
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        update()
+    }
+
+    override func update() {
+        super.update()
+        layer.cornerRadius = bounds.width / 2
+        let inset = max(bounds.width * 0.12, 4)
+        let ringRect = bounds.insetBy(dx: inset, dy: inset)
+        let ringPath = UIBezierPath(ovalIn: ringRect)
+        ringLayer.path = ringPath.cgPath
+        activeRingLayer.path = ringPath.cgPath
+
+        let center = CGPoint(x: bounds.midX, y: bounds.midY)
+        let radius = ringRect.width / 2
+        for (index, spoke) in spokeLayers.enumerated() {
+            let angle = RadialSelectorModel.defaultSlots[index].angle
+            let end = CGPoint(x: center.x + cos(angle) * radius, y: center.y + sin(angle) * radius)
+            let path = UIBezierPath()
+            path.move(to: center)
+            path.addLine(to: end)
+            spoke.path = path.cgPath
+        }
+    }
+
+    override func focus(_ focus: Bool) {
+        layer.borderWidth = 0
+        activeRingLayer.isHidden = !focus
+        ringLayer.strokeColor = (focus ? UIColor.systemYellow : UIColor.systemTeal.withAlphaComponent(0.8)).cgColor
+    }
+}
+
+class RadialSelectorSlotElement: Element {
+    override func commonInit() {
+        super.commonInit()
+        backgroundColor = UIColor.black.withAlphaComponent(0.8)
+        titleLabel?.font = UIFont.systemFont(ofSize: 16, weight: .bold)
+    }
+
+    override func update() {
+        super.update()
+        layer.cornerRadius = bounds.width / 2
+    }
+}
+
 extension UIView {
     func setX(xCoord: CGFloat) {
         self.center = CGPoint(x: xCoord, y: self.center.y)
diff --git a/PlayTools/Editor/Views/KeymapHUDView.swift b/PlayTools/Editor/Views/KeymapHUDView.swift
new file mode 100644
index 00000000..d3e2f5fb
--- /dev/null
+++ b/PlayTools/Editor/Views/KeymapHUDView.swift
@@ -0,0 +1,178 @@
+import UIKit
+
+final class KeymapHUDWindow: UIWindow {
+    override init(windowScene: UIWindowScene) {
+        super.init(windowScene: windowScene)
+        rootViewController = UIViewController()
+        windowLevel = .statusBar + 1
+        backgroundColor = .clear
+        isUserInteractionEnabled = false
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+}
+
+final class KeymapHUDView: UIView {
+    private let map: KeymappingData
+    private let opacity: CGFloat
+
+    init(map: KeymappingData) {
+        self.map = map
+        self.opacity = Self.normalizedOpacity(map.hudOpacity)
+        super.init(frame: screen.screenRect)
+        backgroundColor = .clear
+        isUserInteractionEnabled = false
+        buildLabels()
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    private static func normalizedOpacity(_ value: CGFloat?) -> CGFloat {
+        min(max(value ?? 0.4, 0.1), 1.0)
+    }
+
+    private func buildLabels() {
+        map.buttonModels.forEach { addLabel(title: title(for: $0), transform: $0.transform) }
+        map.draggableButtonModels.forEach {
+            addLabel(title: title(for: $0), transform: $0.transform, style: .drag)
+        }
+        map.swipeModels.forEach {
+            addLabel(title: swipeTitle(for: $0), transform: $0.transform, style: .swipe)
+        }
+        map.joystickModel.forEach {
+            addLabel(title: joystickTitle(for: $0), transform: $0.transform, style: .area)
+        }
+        map.mouseAreaModel.forEach {
+            addLabel(title: ButtonModel.displayName(for: $0.keyName), transform: $0.transform, style: .area)
+        }
+    }
+
+    private enum LabelStyle {
+        case button
+        case drag
+        case swipe
+        case area
+
+        var color: UIColor {
+            switch self {
+            case .button:
+                return .darkGray
+            case .drag:
+                return .systemBlue
+            case .swipe:
+                return .systemPink
+            case .area:
+                return .black
+            }
+        }
+    }
+
+    private func addLabel(title: String, transform: KeyModelTransform, style: LabelStyle = .button) {
+        let size = labelSize(for: title, transform: transform, style: style)
+        let label = UILabel(frame: CGRect(origin: .zero, size: size))
+        label.center = CGPoint(x: transform.xCoord.absoluteX, y: transform.yCoord.absoluteY)
+        label.text = title
+        label.textAlignment = .center
+        label.textColor = .white
+        label.font = UIFont.systemFont(ofSize: fontSize(for: style), weight: .bold)
+        label.numberOfLines = 2
+        label.adjustsFontSizeToFitWidth = true
+        label.minimumScaleFactor = 0.55
+        label.backgroundColor = style.color.withAlphaComponent(opacity)
+        label.layer.cornerRadius = cornerRadius(for: size, style: style)
+        label.layer.borderWidth = 0
+        label.clipsToBounds = true
+        addSubview(label)
+    }
+
+    private func labelSize(for title: String, transform: KeyModelTransform, style: LabelStyle) -> CGSize {
+        switch style {
+        case .swipe:
+            return CGSize(width: 78, height: 48)
+        case .area:
+            return CGSize(width: 86, height: 40)
+        case .button, .drag:
+            let baseSize = min(max(transform.size.absoluteSize, 52), 76)
+            let width = title.contains("+") ? max(baseSize, 68) : baseSize
+            return CGSize(width: width, height: baseSize)
+        }
+    }
+
+    private func fontSize(for style: LabelStyle) -> CGFloat {
+        switch style {
+        case .area:
+            return 16
+        case .swipe:
+            return 17
+        case .button, .drag:
+            return 16
+        }
+    }
+
+    private func cornerRadius(for size: CGSize, style: LabelStyle) -> CGFloat {
+        switch style {
+        case .swipe:
+            return 14
+        case .area:
+            return size.height / 2
+        case .button, .drag:
+            return min(size.width, size.height) / 2
+        }
+    }
+
+    private func title(for button: Button) -> String {
+        let keyName = ButtonModel.displayName(for: button.keyName)
+        let holdPrefix = button.holdDuration == nil ? "" : "Hold "
+        guard let modifierName = button.modifierKeyName, !modifierName.isEmpty else {
+            return "\(holdPrefix)\(keyName)"
+        }
+        return "\(holdPrefix)\(ButtonModel.displayName(for: modifierName))+\n\(keyName)"
+    }
+
+    private func swipeTitle(for swipe: Swipe) -> String {
+        let keyName = title(for: Button(keyCode: swipe.keyCode,
+                                       keyName: swipe.keyName,
+                                       modifierKeyCode: swipe.modifierKeyCode,
+                                       modifierKeyName: swipe.modifierKeyName,
+                                       holdDuration: swipe.holdDuration,
+                                       transform: swipe.transform))
+        return "\(directionArrow(for: swipe.angle))\n\(keyName)"
+    }
+
+    private func joystickTitle(for joystick: Joystick) -> String {
+        switch joystick.keyName {
+        case "Left Thumbstick":
+            return "LS"
+        case "Right Thumbstick":
+            return "RS"
+        case "Mouse":
+            return "Mouse"
+        default:
+            return ButtonModel.displayName(for: joystick.keyName)
+        }
+    }
+
+    private func directionArrow(for angle: CGFloat) -> String {
+        let twoPi = CGFloat.pi * 2
+        let normalized = angle.truncatingRemainder(dividingBy: twoPi) + (angle < 0 ? twoPi : 0)
+        let directions: [(CGFloat, String)] = [
+            (0, "→"),
+            (CGFloat.pi / 2, "↓"),
+            (CGFloat.pi, "←"),
+            (CGFloat.pi * 3 / 2, "↑")
+        ]
+        return directions.min {
+            angularDistance($0.0, normalized) < angularDistance($1.0, normalized)
+        }?.1 ?? "↑"
+    }
+
+    private func angularDistance(_ lhs: CGFloat, _ rhs: CGFloat) -> CGFloat {
+        let twoPi = CGFloat.pi * 2
+        let distance = abs(lhs - rhs).truncatingRemainder(dividingBy: twoPi)
+        return min(distance, twoPi - distance)
+    }
+}
diff --git a/PlayTools/Keymap/Keymapping.swift b/PlayTools/Keymap/Keymapping.swift
index a863c926..836c6340 100644
--- a/PlayTools/Keymap/Keymapping.swift
+++ b/PlayTools/Keymap/Keymapping.swift
@@ -59,6 +59,10 @@ class Keymapping {
         currentKeymapURL.deletingPathExtension().lastPathComponent
     }
 
+    public var keymapCount: Int {
+        keymapOrder.count
+    }
+
     init() {
         baseKeymapURL = URL(fileURLWithPath: "/Users/\(NSUserName())/Library/Containers/io.playcover.PlayCover")
             .appendingPathComponent("Keymapping")
@@ -161,6 +165,8 @@ struct KeymappingData: Codable {
     var joystickModel: [Joystick] = []
     var mouseAreaModel: [MouseArea] = []
     var swipeModels: [Swipe] = []
+    var radialSelectorModels: [RadialSelector] = []
+    var hudOpacity: CGFloat?
     var bundleIdentifier: String
     var version = "2.0.0"
 
@@ -169,6 +175,8 @@ struct KeymappingData: Codable {
          joystickModel: [Joystick] = [],
          mouseAreaModel: [MouseArea] = [],
          swipeModels: [Swipe] = [],
+         radialSelectorModels: [RadialSelector] = [],
+         hudOpacity: CGFloat? = nil,
          bundleIdentifier: String,
          version: String = "2.0.0") {
         self.buttonModels = buttonModels
@@ -176,6 +184,8 @@ struct KeymappingData: Codable {
         self.joystickModel = joystickModel
         self.mouseAreaModel = mouseAreaModel
         self.swipeModels = swipeModels
+        self.radialSelectorModels = radialSelectorModels
+        self.hudOpacity = hudOpacity
         self.bundleIdentifier = bundleIdentifier
         self.version = version
     }
@@ -188,6 +198,8 @@ struct KeymappingData: Codable {
             joystickModel: try container.decodeIfPresent([Joystick].self, forKey: .joystickModel) ?? [],
             mouseAreaModel: try container.decodeIfPresent([MouseArea].self, forKey: .mouseAreaModel) ?? [],
             swipeModels: try container.decodeIfPresent([Swipe].self, forKey: .swipeModels) ?? [],
+            radialSelectorModels: try container.decodeIfPresent([RadialSelector].self, forKey: .radialSelectorModels) ?? [],
+            hudOpacity: try container.decodeIfPresent(CGFloat.self, forKey: .hudOpacity),
             bundleIdentifier: try container.decode(String.self, forKey: .bundleIdentifier),
             version: try container.decodeIfPresent(String.self, forKey: .version) ?? "2.0.0"
         )
diff --git a/PlayTools/Utils/Toast.swift b/PlayTools/Utils/Toast.swift
index 6cdfc844..d3c79c65 100644
--- a/PlayTools/Utils/Toast.swift
+++ b/PlayTools/Utils/Toast.swift
@@ -66,6 +66,13 @@ class Toast {
 
     public static func showHint(title: String, text: [String] = [], timeout: Double = -3,
                                 notification: NSNotification.Name? = nil) {
+        guard Thread.isMainThread else {
+            DispatchQueue.main.async {
+                showHint(title: title, text: text, timeout: timeout, notification: notification)
+            }
+            return
+        }
+
         let parent = screen.keyWindow!
 
         // Width and height here serve as an upper limit.
diff --git a/PlayTools/en.lproj/Playtools.strings b/PlayTools/en.lproj/Playtools.strings
index 04496fa10a9ebde847cff5dbfa5ab6137447282b..1edf6abf498168b028b265ae5192749396257210 100644
GIT binary patch
delta 1130
zcmb_bO-lk%6uq>Hz6KL36Y^n1NM(gYP(+C>gtUZe6)jAMlx#+tY7&Be#B0-{T|c0I
zB>jPYL+8G6nm1au2^n?XJNMjk&%O6^?RodznvritN<NN{#R_ColWKHAH`Jg@d`!BL
zor$<ijZG$-xV3P$LM_~z<lrOd*2l^hV})53kEssionk^f9RS;=YpNjbm|QU5QkCk=
zyX5p>1zl-qfeZou)kx>+h^_&V0hf*c7PvS^3QBhHq^QtE2r4NR4(<h&eKf1gd;0Hz
zWSve(VZc;YRR$=b<0RB%EpR_TfnH${f7rbZ$9+sKK4p+I?2+aRYBNz+g)ZQriE0DJ
zUS|img_?U=wrK=ha8Met#Ge{!aL4%v75zL)ha8P1^BMSWp~^NL;n)1dN4{f>P-yO^
zHX{;#me|klIZ>Yd+!5Vnb~eOBTX<ifJuv1XeVZV2(S$5U<~Ejr^0Kv%iQjC@iNI3<
zV*}q!g)mk3s+bPk%k$~nJa@cryRd7v+BDT`xjr<VE#hRro*^seV_x1+FAmelySG`O
zQ`+yF7?)PHz0kc8I7bA#h?+UppG}u6c{Ut3yi=~3^}Dh&m5%yIZyR|Z6?WFgYUj|x
G{r&<)^WL@q

delta 7
OcmbPY|IT1To&*35_X8*Z

diff --git a/PlayTools/zh-Hans.lproj/Playtools.strings b/PlayTools/zh-Hans.lproj/Playtools.strings
index b8f74956b02ccab29e6ac6316b60ab21a3c29c47..1ae43ef4f6c0dc970b93615dbb76f313ce89d800 100644
GIT binary patch
delta 835
zcmah{OG^S_6urU3q)xjYAVg+ZVlujr2zwwUAw-6cTInLkS74)LYO@I21hvZev~Ank
zL~Z*M<tADQZCnIx`~!8bq2rVh!!RGiJ?GqWzVl*iTJCp-S&=id$3em6gDhkq4q-Te
zJxJk`z>^tFu#B%6_+U)(#B`Olfa$ng(@D+qdWhvXD}lWsNF%(^CLq`bf)&_@UC2QQ
zN=SGJ63(b}j<B`hfPCPic6%b$h@53OyO_q&ID$n4X7MZ|P`gLv>gm*U&8K<ktV;T>
z9O@;Yh{Lo&UZbt*>HXlh`AtbKvUw?&322uQc7*)B%c=l_7T^?S)<tC3`t0>4BAtwm
zW0*n$O{i3@D7o$WZ16VUe^ha_lmCNE6B?4ui|AZNRRy;2oA|@fdq|hkWPp~IXb<&z
zXzl)Kw4!uHo%oEO7VrRb3ZBuvwP90+aaIwAMs(6$b--DdZ-N9Ji^&(SMb_XKCMm|>
zZ42XHYF>st=qChH{Moc=A8doSC)<^zTX8_U6sYhlxs_G+#?Q`u&vjxhVJ^M*K`7d&
ZJCF4zUJ>t?3P=^yA~XsSGc1B0z5s9W$dLd5

delta 7
OcmaE+dQECW7%u=0jsp(>

diff --git a/PlayTools/zh-Hant.lproj/Playtools.strings b/PlayTools/zh-Hant.lproj/Playtools.strings
index ed60b89c47319bc2c37b5775c777dddd6a16d56b..0d6171c08523c314b76bebddedd058dcbbbb5e5b 100644
GIT binary patch
literal 1428
zcmbtUze@sf9Q_1=XmdeL$3YMc+H3?u1wv%`YfB>UF0JfNI)6e@OM@+0VYD?j_E$7C
zltWXEO^r@X+54Q>oqGOCMDG0F`QGQf&-;ApKQ0pKkQ7oWOKv*AT@k-`D2>k^P7^rI
zkcMl5Qh4geeTrm?&=H>Vse(I^1X{vZBuD67^2H0~<)CnquQ;Xe(s53tMH-eTOi3_h
z4K8L_vs4zQJh(F?;T@BCJ35#3&_|_Ic{t17a2>+#_|~A@Ng&GLa6`9dD9^Mhd%S%)
zud2emLz><n6g7>?70LmRwdgG>%*tH>3QTNrwd+^v>7dvukPC3Z>WqmwVT;KsRs5%0
zr}Z}1txmhary?0~BL}j@`C5#<w{v|oJ{i^OT^PIdxgVnj4Jl-N16QSscVA&=!mcCz
zuyso=6{N|&GqqSVo80Z0`Yie2Wn)5mGpquWbFU#)ZaAYDose*1Kb1VW{65dEnT+QP
zf3Q$~lAY4z_1HpHeG75&rsDILpE>Kq3{wlwYUfsn;Iz3nWMhwXR?~1}luhBMD6LrZ
vX?NbDhj?09&8y@s%70s+x26UXJIi|VNQmiLEylS2MPy#t*e|V^c2)iY<c}?<

literal 4
LcmezWkBb2S2Mz)V


From e9d4fe997900acc2e70fe5bbac19b593beb0fdea Mon Sep 17 00:00:00 2001
From: wqf <wukingfen@gmail.com>
Date: Sun, 24 May 2026 14:35:40 +0800
Subject: [PATCH 10/10] =?UTF-8?q?fix:=20prioritize=20radial=20selector=20o?=
 =?UTF-8?q?ver=20thumbstick=20drag=20/=20=E4=BF=AE=E5=A4=8D=E8=BD=AE?=
 =?UTF-8?q?=E7=9B=98=E4=BC=98=E5=85=88=E4=BA=8E=E6=91=87=E6=9D=86=E6=8B=96?=
 =?UTF-8?q?=E6=8B=BD?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 PlayTools/Controls/ActionDispatcher.swift          | 9 ++++++---
 PlayTools/Controls/Backend/Action/PlayAction.swift | 3 ++-
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/PlayTools/Controls/ActionDispatcher.swift b/PlayTools/Controls/ActionDispatcher.swift
index 4f9414b2..41fa54d7 100644
--- a/PlayTools/Controls/ActionDispatcher.swift
+++ b/PlayTools/Controls/ActionDispatcher.swift
@@ -149,10 +149,13 @@ public class ActionDispatcher {
         atomicHandler?.store(AtomicHandler(key, modifierKeys, handler), ordering: .releasing)
     }
 
-    static public func unregister(key: String) {
+    static public func unregister(key: String,
+                                  modifierKeys: [String] = [],
+                                  priority: ActionDispatchPriority = .DRAGGABLE) {
         // Only draggable can be unregistered
-        let atomicHandler = directionPadHandlers[ActionDispatchPriority.DRAGGABLE.rawValue].first(where: { handler in
-            handler.load(ordering: .relaxed).key == key
+        let atomicHandler = directionPadHandlers[priority.rawValue].first(where: { handler in
+            let handlerValue = handler.load(ordering: .relaxed)
+            return handlerValue.key == key && handlerValue.modifierKeys == modifierKeys
         })
 //        DispatchQueue.main.async {
 //            if screen.keyWindow == nil {
diff --git a/PlayTools/Controls/Backend/Action/PlayAction.swift b/PlayTools/Controls/Backend/Action/PlayAction.swift
index a2835737..53af9d76 100644
--- a/PlayTools/Controls/Backend/Action/PlayAction.swift
+++ b/PlayTools/Controls/Backend/Action/PlayAction.swift
@@ -513,7 +513,8 @@ class RadialSelectorAction: Action {
 
         ActionDispatcher.register(key: keyName,
                                   modifierKeys: modifierKeys,
-                                  handler: self.thumbstickUpdated)
+                                  handler: self.thumbstickUpdated,
+                                  priority: .DRAGGABLE)
         for modifierKey in modifierKeys {
             ActionDispatcher.register(key: modifierKey, handler: self.modifierUpdated)
         }