Applescript - ignorar las teclas modificadoras

Bueno, es difícil demostrar que es negativo, pero, como dice la pregunta que te vinculaste: estás sosteniendo las teclas ⌘ y ⇧ abajo al llamar al script. No puede ignorarlos. Apple script es scripting , y está mucho más cerca de los scripts GUI que de los scripts aplicativos.

No puedo ofrecer otra idea que no sea en la respuesta a la pregunta que envió: solo agregue un poco de retraso para que suelte las teclas antes de enviar las pulsaciones.

delay 0.2

La solución más robusta es hacer una llamada al sistema que verifique qué teclas modificadoras están presionadas actualmente. La siguiente solución utiliza un pequeño archivo ejecutable externo escrito en C que puede compilar usted mismo desde la línea de comandos (siempre que tenga instalado Xcode).

Si no sabes C, no te preocupes! Solo necesitarás copiar y pegar el código C. Se llama mediante un simple controlador de AppleScript.

Nota técnica: El siguiente código se basa en el marco Carbon de macOS. También debería ser posible crear una solución Cocoa que permita que todo se llame directamente desde AppleScript utilizando AppleScript-Objective-C.

Crea el ejecutable compilado

Siga estas instrucciones para crear un programa de línea de comandos que imprima las claves modificadoras actuales. Usted debe tener Xcode Command Line Tools (o el Xcode completo) instalados para compilar el código.

1. Guarde el siguiente código como getModifierKeys.c en la carpeta de Escritorio:

   #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. Compile el programa ejecutando los siguientes comandos desde la Terminal:

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

3. Ahora tendrá un archivo ejecutable llamado getModifierKeys en su escritorio. Mueve esto a donde quieras almacenarlo.

Llame al ejecutable desde AppleScript

El siguiente controlador se utiliza para llamar al ejecutable de AppleScript. El controlador bloqueará hasta que ya no se presionen las teclas modificadoras especificadas.

1. Copie el siguiente controlador en su AppleScript y reemplace /PATH/TO/EXECUTABLE con la ruta absoluta al ejecutable que creó en el paso anterior (si no lo movió, se ubicará en /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. Llame al controlador antes del comando keystroke (o cualquier otro comando que se comporte de manera impredecible cuando se presionan las teclas modificadoras), especificando las teclas que no desea que se presionen.

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

Los modificadores "fn" y "caps" no se utilizan en este ejemplo; tenga en cuenta también que el modificador "mayúsculas" indica si el bloqueo de mayúsculas está activo, no si la tecla está presionada físicamente.

FastScripts hace una pausa en la ejecución de los scripts antes de las pulsaciones de teclas y los comandos de código de teclas si las teclas modificadoras no han sido puestos en libertad.

  

Un buen truco en 2.6.1 es la forma en que FastScripts se comporta cuando sus scripts incluyen comandos de "pulsación de tecla" para sintetizar pulsaciones de teclado. En el pasado, estos scripts eran difíciles de encontrar en FastScripts, ya que la combinación de teclas sintetizada se confundiría con las mismas claves que había utilizado para invocar el script. Ahora, FastScripts suspenderá la ejecución de cualquiera de estos scripts hasta que libere las teclas que se presionaron para invocar el script.

FastScripts no admite la activación de secuencias de comandos con acciones de dispositivo señalador, pero podría usar KeyRemap4MacBook para asignar puntos Las acciones del dispositivo a algunas combinaciones de teclas no utilizadas primero.