Use inputWithModifiers for terminal input

Replaces the call to term.input with inputWithModifiers in the type(text:) method to handle input with modifier keys. This may improve support for complex input scenarios in the terminal.

Add lock functionality for Ctrl and Alt modifiers in terminal

Introduces the ability to lock the Control and Alt modifier keys in the terminal keyboard toolbar via double-tap, with visual feedback and state management. Updates Swift and JavaScript code to support locked states, ensuring modifiers remain active until explicitly unlocked, and modifies reset logic to respect locked states.

Author: ThalesMMS

CodeApp/Managers/TerminalInstance.swift

@@ -540,7 +540,7 @@ extension TerminalInstance: WKUIDelegate {
 extension TerminalInstance {
     func type(text: String) {
         guard let base64 = text.base64Encoded() else { return }
-        executeScript("term.input(base64ToString(`\(base64)`))")
+        executeScript("inputWithModifiers(base64ToString(`\(base64)`))")
     }
 
     func moveCursor(codeSequence: String) {
@@ -551,9 +551,17 @@ extension TerminalInstance {
         executeScript("setControlActive(\(active), \(generation))")
     }
 
+    func setControlLocked(_ locked: Bool) {
+        executeScript("setControlLocked(\(locked))")
+    }
+
     func setAltActive(_ active: Bool, generation: Int) {
         executeScript("setAltActive(\(active), \(generation))")
     }
+
+    func setAltLocked(_ locked: Bool) {
+        executeScript("setAltLocked(\(locked))")
+    }
 }
 
 extension Notification.Name {

CodeApp/Views/TerminalKeyboardToolbar.swift

@@ -13,25 +13,97 @@ struct TerminalKeyboardToolBar: View {
     @Environment(\.horizontalSizeClass) var horizontalSizeClass
     @State var pasteBoardHasContent = false
     @State var controlActive = false
+    @State var controlLocked = false
+    @State var controlLastTapTime: Date?
     @State var controlGeneration = 0
     @State var altActive = false
+    @State var altLocked = false
+    @State var altLastTapTime: Date?
     @State var altGeneration = 0
 
+    private let doubleTapInterval: TimeInterval = 0.3
+
     private func resetModifierStates() {
         controlActive = false
+        controlLocked = false
         App.terminalInstance.setControlActive(false, generation: controlGeneration)
+        App.terminalInstance.setControlLocked(false)
         altActive = false
+        altLocked = false
         App.terminalInstance.setAltActive(false, generation: altGeneration)
+        App.terminalInstance.setAltLocked(false)
+    }
+
+    private func resetUnlockedModifiers() {
+        // Reset modifiers only if they are not locked
+        if !controlLocked {
+            controlActive = false
+            App.terminalInstance.setControlActive(false, generation: controlGeneration)
+        }
+        if !altLocked {
+            altActive = false
+            App.terminalInstance.setAltActive(false, generation: altGeneration)
+        }
+    }
+
+    private func handleControlTap() {
+        let now = Date()
+        let isDoubleTap =
+            controlLastTapTime.map { now.timeIntervalSince($0) < doubleTapInterval } ?? false
+        controlLastTapTime = now
+
+        if controlLocked {
+            // Single tap while locked: unlock and deactivate
+            controlLocked = false
+            controlActive = false
+            controlGeneration += 1
+            App.terminalInstance.setControlLocked(false)
+            App.terminalInstance.setControlActive(false, generation: controlGeneration)
+        } else if isDoubleTap && controlActive {
+            // Double tap while active: lock
+            controlLocked = true
+            App.terminalInstance.setControlLocked(true)
+        } else {
+            // Single tap: toggle active state
+            controlActive.toggle()
+            controlGeneration += 1
+            App.terminalInstance.setControlActive(controlActive, generation: controlGeneration)
+        }
+    }
+
+    private func handleAltTap() {
+        let now = Date()
+        let isDoubleTap =
+            altLastTapTime.map { now.timeIntervalSince($0) < doubleTapInterval } ?? false
+        altLastTapTime = now
+
+        if altLocked {
+            // Single tap while locked: unlock and deactivate
+            altLocked = false
+            altActive = false
+            altGeneration += 1
+            App.terminalInstance.setAltLocked(false)
+            App.terminalInstance.setAltActive(false, generation: altGeneration)
+        } else if isDoubleTap && altActive {
+            // Double tap while active: lock
+            altLocked = true
+            App.terminalInstance.setAltLocked(true)
+        } else {
+            // Single tap: toggle active state
+            altActive.toggle()
+            altGeneration += 1
+            App.terminalInstance.setAltActive(altActive, generation: altGeneration)
+        }
     }
 
     private func typeAndResetModifiers(text: String) {
         App.terminalInstance.type(text: text)
-        resetModifierStates()
+        resetUnlockedModifiers()
     }
 
     private func moveCursorAndResetModifiers(codeSequence: String) {
         App.terminalInstance.moveCursor(codeSequence: codeSequence)
-        resetModifierStates()
+        resetUnlockedModifiers()
     }
 
     var body: some View {
@@ -66,10 +138,7 @@ struct TerminalKeyboardToolBar: View {
                     })
                 Button(
                     action: {
-                        controlActive.toggle()
-                        controlGeneration += 1
-                        App.terminalInstance.setControlActive(
-                            controlActive, generation: controlGeneration)
+                        handleControlTap()
                     },
                     label: {
                         Text("Ctrl")
@@ -78,16 +147,18 @@ struct TerminalKeyboardToolBar: View {
                                 controlActive ? Color.accentColor.opacity(0.3) : Color.clear
                             )
                             .cornerRadius(4)
+                            .overlay(
+                                RoundedRectangle(cornerRadius: 4)
+                                    .stroke(Color.accentColor, lineWidth: controlLocked ? 2 : 0)
+                            )
                     }
                 )
                 .accessibilityLabel("Control")
-                .accessibilityValue(controlActive ? "Active" : "Inactive")
+                .accessibilityValue(
+                    controlLocked ? "Locked" : (controlActive ? "Active" : "Inactive"))
                 Button(
                     action: {
-                        altActive.toggle()
-                        altGeneration += 1
-                        App.terminalInstance.setAltActive(
-                            altActive, generation: altGeneration)
+                        handleAltTap()
                     },
                     label: {
                         Text("Alt")
@@ -96,10 +167,14 @@ struct TerminalKeyboardToolBar: View {
                                 altActive ? Color.accentColor.opacity(0.3) : Color.clear
                             )
                             .cornerRadius(4)
+                            .overlay(
+                                RoundedRectangle(cornerRadius: 4)
+                                    .stroke(Color.accentColor, lineWidth: altLocked ? 2 : 0)
+                            )
                     }
                 )
                 .accessibilityLabel("Alt")
-                .accessibilityValue(altActive ? "Active" : "Inactive")
+                .accessibilityValue(altLocked ? "Locked" : (altActive ? "Active" : "Inactive"))
                 Button(
                     action: {
                         typeAndResetModifiers(text: "\u{1b}[3~")

Dependencies/terminal.bundle/index.html

@@ -155,20 +155,30 @@
       localEcho.addAutocompleteHandler(autocompleteCommonFiles);
 
       var controlActive = false;
+      var controlLocked = false;
       var controlGeneration = 0;
       var altActive = false;
+      var altLocked = false;
       var altGeneration = 0;
 
       function setControlActive(active, generation) {
         controlActive = active;
         controlGeneration = generation;
       }
 
+      function setControlLocked(locked) {
+        controlLocked = locked;
+      }
+
       function setAltActive(active, generation) {
         altActive = active;
         altGeneration = generation;
       }
 
+      function setAltLocked(locked) {
+        altLocked = locked;
+      }
+
       function shouldApplyModifierToCsi(final, params) {
         if (final >= "A" && final <= "D") {
           return true;
@@ -245,23 +255,23 @@
       }
 
       function applyModifierStates(data) {
-        // Capture which modifiers are active before resetting
+        // Capture which modifiers are active before potentially resetting
         var wasControlActive = controlActive;
         var wasAltActive = altActive;
 
         if (!wasControlActive && !wasAltActive) {
           return data;
         }
 
-        // Reset all active modifiers and notify Swift
-        if (wasControlActive) {
+        // Reset modifiers only if not locked, and notify Swift
+        if (wasControlActive && !controlLocked) {
           controlActive = false;
           window.webkit.messageHandlers.toggleMessageHandler2.postMessage({
             Event: "ControlReset",
             Generation: controlGeneration,
           });
         }
-        if (wasAltActive) {
+        if (wasAltActive && !altLocked) {
           altActive = false;
           window.webkit.messageHandlers.toggleMessageHandler2.postMessage({
             Event: "AltReset",