Applescript: ignora i tasti modificatori

Beh, è difficile dimostrare un aspetto negativo, ma, dato che la domanda che hai collegato a te stesso dice: hai che detiene le chiavi ⌘ e ⇧ giù quando si chiama lo script. Non può ignorarli. Lo script di Apple è scripting e molto più vicino allo scripting GUI che allo scripting applicativo.

Non posso offrire altra idea che nella risposta alla domanda che hai inviato: basta aggiungere un leggero ritardo in modo da rilasciare le chiavi prima che i tasti vengano inviati.

delay 0.2

La soluzione più efficace è quella di effettuare una chiamata di sistema che controlla quali tasti modificatori sono attualmente premuti. La seguente soluzione utilizza un piccolo file eseguibile esterno scritto in C che puoi compilare da solo dalla riga di comando (purché Xcode sia installato).

Se non conosci C, non preoccuparti! Dovrai solo copiare e incollare il codice C. Si chiama usando un semplice gestore AppleScript.

Nota tecnica: il seguente codice è basato sul framework Carbon di macOS. Dovrebbe anche essere possibile creare una soluzione Cocoa che permetta di chiamare tutto direttamente da AppleScript usando AppleScript-Objective-C.

Crea l'eseguibile compilato

Segui queste istruzioni per creare un programma da riga di comando che stampi i tasti modificatori correnti. devi avere Xcode Command Line Tools (o il Xcode completo ) installato per compilare il codice.

1. Salva il seguente codice come getModifierKeys.c nella cartella Desktop:

   #include <Carbon/Carbon.h>
   
   // Define the key code for the fn Key.
   const unsigned int fnKey = 131072;
   
   // Define the accepted labels for the modifier keys. The first label is used by the program for output.
   const char *cmdLabels[] = {"command", "cmd", "@", "⌘"};
   const char *controlLabels[] = {"control", "ctrl", "ctl", "^", "⌃"};
   const char *optionLabels[] = {"option", "opt", "alt", "~", "⌥"};
   const char *shiftLabels[] = {"shift", "$", "⇧"};
   const char *fnLabels[] = {"fn", "function", "func"};
   const char *alphaLabels[] = {"caps", "caps lock", "caps_lock", "caps-lock", "capslock", "alpha", "⇪"};
   
   // Define the order to use when returning the modifier keys.
   const unsigned int modifierKeyValues[] = {cmdKey, controlKey, optionKey, shiftKey, fnKey, alphaLock};
   const char **modifierKeyLabels[] = {cmdLabels, controlLabels, optionLabels, shiftLabels, fnLabels, alphaLabels};
   const unsigned int modifierKeyLabelsCount[] = {(sizeof cmdLabels / sizeof *cmdLabels), (sizeof controlLabels / sizeof *controlLabels), (sizeof optionLabels / sizeof *optionLabels), (sizeof shiftLabels / sizeof *shiftLabels), (sizeof fnLabels / sizeof *fnLabels), (sizeof alphaLabels / sizeof *alphaLabels)};
   
   // Get the length of the above arrays.
   const unsigned int modifierKeyCount = (sizeof modifierKeyValues / sizeof *modifierKeyValues);
   
   // Define the label to use for no modifier keys.
   const char *noneLabel = "none";
   
   // Declare the helper function to determine matches to the labels.
   int arg_match(const char *, const char *[], int);
   
   
   // Main function.
   int main (int argc, const char *argv[]) {
       // Get the current modifier key codes.
       unsigned int current_modifier_keys = GetCurrentKeyModifiers();
       unsigned int i;
       unsigned int modifiers_count = 0;
   
       for (i = 0; i < modifierKeyCount; i++) { // Loop through all possible modifier keys again, and print the label.
           if (current_modifier_keys & modifierKeyValues[i]) {
               if (modifiers_count) { printf(" "); }
               modifiers_count++;
               printf("%s", modifierKeyLabels[i][0]);
           }
       }
   
       if (modifiers_count) {
           printf("\n");
       } else {
           printf("%s\n", noneLabel);
       }
   
       return 0;
   }
   
   // Helper function to determine matches to the labels.
   int arg_match(const char *arg_string, const char *key_labels[], int key_labels_length) {
       for (int i = 0; i < key_labels_length; i++) {
           if (0 == strcasecmp(arg_string, key_labels[i])) {
               return 1;
           }
       }
       return 0;
   }
   

2. Compila il programma eseguendo i seguenti comandi da Terminale:

   cd ~/Desktop
   gcc -framework Carbon getModifierKeys.c -o getModifierKeys
   

3. Ora avrai un file eseguibile denominato getModifierKeys sul desktop. Sposta questo ovunque desideri memorizzarlo.

Chiama l'eseguibile da AppleScript

Il seguente gestore viene utilizzato per chiamare l'eseguibile per AppleScript. Il gestore si bloccherà fino a quando i tasti modificatori specificati non verranno più premuti.

1. Copia il seguente gestore nel tuo AppleScript e sostituisci /PATH/TO/EXECUTABLE con il percorso assoluto dell'eseguibile creato nel passaggio precedente (se non lo hai spostato, si troverà in /Users/USERNAME/Desktop/getModifierKeys ).

   to waitForModifierKeyRelease(modifier_keys)
       (*    (string OR list of strings) → nothing
   
       Block execution until all of the keys specified in modifier_keys are released.
       Modifier keys are specified by their name; multiple keys may be specified in a space-delimited string or in a list.
       The possible modifier keys are "command", "control", "option", "shift", "fn", and "caps".
   
       Parameters:
       modifier_keys [string OR list of strings] : The modifier keys to await release.
   
       Result:
       [nothing] : No return value.    *)
   
       set should_wait to true
       repeat while should_wait
           set current_modifier_keys to do shell script quoted form of "/PATH/TO/EXECUTABLE"
   
           set should_wait to false
           set should_wait to should_wait or (current_modifier_keys contains "command" and modifier_keys contains "command")
           set should_wait to should_wait or (current_modifier_keys contains "control" and modifier_keys contains "control")
           set should_wait to should_wait or (current_modifier_keys contains "option" and modifier_keys contains "option")
           set should_wait to should_wait or (current_modifier_keys contains "shift" and modifier_keys contains "shift")
           set should_wait to should_wait or (current_modifier_keys contains "fn" and modifier_keys contains "fn")
           set should_wait to should_wait or (current_modifier_keys contains "caps" and modifier_keys contains "caps")
       end repeat
   
       return
   
   end waitForModifierKeyRelease
   

2. Chiama il gestore prima del comando keystroke (o di qualsiasi altro comando che si comporta in maniera imprevedibile quando vengono premuti i tasti modificatori), specificando i tasti che non desideri vengano premuti.

   my waitForModifierKeyRelease({"command", "control", "option", "shift"})
   

I modificatori "fn" e "caps" non sono usati in questo esempio; si noti inoltre che il modificatore "Caps" indica se Caps Lock è attivo, non se il tasto è fisicamente premuto.

FastScripts sospende l'esecuzione di script prima della sequenza di tasti e dei comandi del codice tasto se i tasti modificatori non sono stati rilasciati.

One cool trick in 2.6.1 is the way FastScripts behaves when your scripts include “keystroke” commands to synthesize keyboard presses. In the past, these scripts were tricky to get right in FastScripts, because the synthesized keystroke would be mixed up with the very keys you had used to invoke the script. Now, FastScripts will suspend execution of any such script until you release the keys that were pressed to invoke the script.

FastScripts non supporta gli script di attivazione con le azioni del dispositivo di puntamento, ma puoi utilizzare KeyRemap4MacBook per mappare il puntamento azioni del dispositivo su alcune combinazioni di tasti non utilizzate.